diff --git a/app/app.go b/app/app.go
index d93e7cb7..ed57f4ae 100644
--- a/app/app.go
+++ b/app/app.go
@@ -14,13 +14,6 @@ import (
 	"syscall"
 	"time"
 
-	"github.com/ChainSafe/chainbridge-core/chains/evm/calls/evmgaspricer"
-	"github.com/ChainSafe/chainbridge-core/crypto/secp256k1"
-	"github.com/ChainSafe/chainbridge-core/flags"
-	"github.com/ChainSafe/chainbridge-core/logger"
-	"github.com/ChainSafe/chainbridge-core/lvldb"
-	"github.com/ChainSafe/chainbridge-core/opentelemetry"
-	"github.com/ChainSafe/chainbridge-core/store"
 	"github.com/ChainSafe/sygma-relayer/chains/evm"
 	"github.com/ChainSafe/sygma-relayer/chains/evm/calls/contracts/bridge"
 	"github.com/ChainSafe/sygma-relayer/chains/evm/calls/events"
@@ -28,21 +21,28 @@ import (
 	"github.com/ChainSafe/sygma-relayer/chains/evm/listener/depositHandlers"
 	hubEventHandlers "github.com/ChainSafe/sygma-relayer/chains/evm/listener/eventHandlers"
 	"github.com/ChainSafe/sygma-relayer/chains/substrate"
+	"github.com/sygmaprotocol/sygma-core/chains/evm/transactor/gas"
 	coreSubstrate "github.com/sygmaprotocol/sygma-core/chains/substrate"
+	"github.com/sygmaprotocol/sygma-core/crypto/secp256k1"
+	"github.com/sygmaprotocol/sygma-core/observability"
+	"github.com/sygmaprotocol/sygma-core/relayer"
+	"github.com/sygmaprotocol/sygma-core/relayer/message"
+	"github.com/sygmaprotocol/sygma-core/store"
+	"github.com/sygmaprotocol/sygma-core/store/lvldb"
 
 	substrateExecutor "github.com/ChainSafe/sygma-relayer/chains/substrate/executor"
-	substrate_listener "github.com/ChainSafe/sygma-relayer/chains/substrate/listener"
-	substrate_pallet "github.com/ChainSafe/sygma-relayer/chains/substrate/pallet"
+	substrateListener "github.com/ChainSafe/sygma-relayer/chains/substrate/listener"
+	substratePallet "github.com/ChainSafe/sygma-relayer/chains/substrate/pallet"
 	"github.com/ChainSafe/sygma-relayer/metrics"
 	"github.com/centrifuge/go-substrate-rpc-client/v4/signature"
 	coreEvm "github.com/sygmaprotocol/sygma-core/chains/evm"
-	coreClient "github.com/sygmaprotocol/sygma-core/chains/evm/client"
+	evmClient "github.com/sygmaprotocol/sygma-core/chains/evm/client"
 	"github.com/sygmaprotocol/sygma-core/chains/evm/listener"
 	"github.com/sygmaprotocol/sygma-core/chains/evm/transactor/monitored"
 	"github.com/sygmaprotocol/sygma-core/chains/evm/transactor/transaction"
-	"github.com/sygmaprotocol/sygma-core/chains/substrate/client"
+	substrateClient "github.com/sygmaprotocol/sygma-core/chains/substrate/client"
 	"github.com/sygmaprotocol/sygma-core/chains/substrate/connection"
-	core_substrate_listener "github.com/sygmaprotocol/sygma-core/chains/substrate/listener"
+	coreSubstrateListener "github.com/sygmaprotocol/sygma-core/chains/substrate/listener"
 
 	"github.com/ChainSafe/sygma-relayer/comm/elector"
 	"github.com/ChainSafe/sygma-relayer/comm/p2p"
@@ -56,9 +56,6 @@ import (
 	"github.com/libp2p/go-libp2p/core/crypto"
 	"github.com/rs/zerolog/log"
 	"github.com/spf13/viper"
-
-	"github.com/sygmaprotocol/sygma-core/relayer"
-	coreMessage "github.com/sygmaprotocol/sygma-core/relayer/message"
 )
 
 var Version string
@@ -66,7 +63,7 @@ var Version string
 func Run() error {
 	var err error
 
-	configFlag := viper.GetString(flags.ConfigFlagName)
+	configFlag := viper.GetString(config.ConfigFlagName)
 	configURL := viper.GetString("config-url")
 
 	configuration := &config.Config{}
@@ -83,7 +80,7 @@ func Run() error {
 		panicOnError(err)
 	}
 
-	logger.ConfigureLogger(configuration.RelayerConfig.LogLevel, os.Stdout)
+	observability.ConfigureLogger(configuration.RelayerConfig.LogLevel, os.Stdout)
 
 	log.Info().Msg("Successfully loaded configuration")
 
@@ -123,7 +120,7 @@ func Run() error {
 	// effectively it waits until old instance is killed
 	var db *lvldb.LVLDB
 	for {
-		db, err = lvldb.NewLvlDB(viper.GetString(flags.BlockstoreFlagName))
+		db, err = lvldb.NewLvlDB(viper.GetString(config.BlockstoreFlagName))
 		if err != nil {
 			log.Error().Err(err).Msg("Unable to connect to blockstore file, retry in 10 seconds")
 			time.Sleep(10 * time.Second)
@@ -138,7 +135,7 @@ func Run() error {
 	exitLock := &sync.RWMutex{}
 	defer exitLock.Lock()
 
-	mp, err := opentelemetry.InitMetricProvider(context.Background(), configuration.RelayerConfig.OpenTelemetryCollectorURL)
+	mp, err := observability.InitMetricProvider(context.Background(), configuration.RelayerConfig.OpenTelemetryCollectorURL)
 	if err != nil {
 		panic(err)
 	}
@@ -164,13 +161,13 @@ func Run() error {
 				kp, err := secp256k1.NewKeypairFromString(config.GeneralChainConfig.Key)
 				panicOnError(err)
 
-				client, err := coreClient.NewEVMClient(config.GeneralChainConfig.Endpoint, kp)
+				client, err := evmClient.NewEVMClient(config.GeneralChainConfig.Endpoint, kp)
 				panicOnError(err)
 
 				log.Info().Str("domain", config.String()).Msgf("Registering EVM domain")
 
 				bridgeAddress := common.HexToAddress(config.Bridge)
-				gasPricer := evmgaspricer.NewLondonGasPriceClient(client, &evmgaspricer.GasPricerOpts{
+				gasPricer := gas.NewLondonGasPriceClient(client, &gas.GasPricerOpts{
 					UpperLimitFeePerGas: config.MaxGasPrice,
 					GasPriceFactor:      config.GasMultiplier,
 				})
@@ -179,7 +176,7 @@ func Run() error {
 				bridgeContract := bridge.NewBridgeContract(client, bridgeAddress, t)
 
 				depositHandler := depositHandlers.NewETHDepositHandler(bridgeContract)
-				mh := coreMessage.NewMessageHandler()
+				mh := message.NewMessageHandler()
 				for _, handler := range config.Handlers {
 
 					mh.RegisterMessageHandler("Transfer", &executor.TransferMessageHandler{})
@@ -207,10 +204,10 @@ func Run() error {
 				tssListener := events.NewListener(client)
 				eventHandlers := make([]listener.EventHandler, 0)
 				l := log.With().Str("chain", fmt.Sprintf("%v", config.GeneralChainConfig.Name)).Uint8("domainID", *config.GeneralChainConfig.Id)
-				eventHandlers = append(eventHandlers, hubEventHandlers.NewDepositEventHandler(depositListener, depositHandler, bridgeAddress, *config.GeneralChainConfig.Id, make(chan []*coreMessage.Message, 1)))
+				eventHandlers = append(eventHandlers, hubEventHandlers.NewDepositEventHandler(depositListener, depositHandler, bridgeAddress, *config.GeneralChainConfig.Id, make(chan []*message.Message, 1)))
 				eventHandlers = append(eventHandlers, hubEventHandlers.NewKeygenEventHandler(l, tssListener, coordinator, host, communication, keyshareStore, bridgeAddress, networkTopology.Threshold))
 				eventHandlers = append(eventHandlers, hubEventHandlers.NewRefreshEventHandler(l, topologyProvider, topologyStore, tssListener, coordinator, host, communication, connectionGate, keyshareStore, bridgeAddress))
-				eventHandlers = append(eventHandlers, hubEventHandlers.NewRetryEventHandler(l, tssListener, depositHandler, bridgeAddress, *config.GeneralChainConfig.Id, config.BlockConfirmations, make(chan []*coreMessage.Message, 1)))
+				eventHandlers = append(eventHandlers, hubEventHandlers.NewRetryEventHandler(l, tssListener, depositHandler, bridgeAddress, *config.GeneralChainConfig.Id, config.BlockConfirmations, make(chan []*message.Message, 1)))
 				evmListener := listener.NewEVMListener(client, eventHandlers, blockstore, sygmaMetrics, *config.GeneralChainConfig.Id, config.BlockRetryInterval, config.BlockConfirmations, config.BlockInterval)
 				executor := executor.NewExecutor(host, communication, coordinator, bridgeContract, keyshareStore, exitLock, config.GasLimit.Uint64())
 
@@ -234,21 +231,21 @@ func Run() error {
 					panic(err)
 				}
 
-				substrateClient := client.NewSubstrateClient(conn, &keyPair, config.ChainID, config.Tip)
-				bridgePallet := substrate_pallet.NewPallet(substrateClient)
+				substrateClient := substrateClient.NewSubstrateClient(conn, &keyPair, config.ChainID, config.Tip)
+				bridgePallet := substratePallet.NewPallet(substrateClient)
 
 				log.Info().Str("domain", config.String()).Msgf("Registering substrate domain")
 
 				l := log.With().Str("chain", fmt.Sprintf("%v", config.GeneralChainConfig.Name)).Uint8("domainID", *config.GeneralChainConfig.Id)
-				depositHandler := substrate_listener.NewSubstrateDepositHandler()
-				depositHandler.RegisterDepositHandler(substrate.FungibleTransfer, substrate_listener.FungibleTransferHandler)
-				eventHandlers := make([]core_substrate_listener.EventHandler, 0)
-				eventHandlers = append(eventHandlers, substrate_listener.NewFungibleTransferEventHandler(l, *config.GeneralChainConfig.Id, depositHandler, make(chan []*coreMessage.Message, 1), conn))
-				eventHandlers = append(eventHandlers, substrate_listener.NewRetryEventHandler(l, conn, depositHandler, *config.GeneralChainConfig.Id, make(chan []*coreMessage.Message, 1)))
+				depositHandler := substrateListener.NewSubstrateDepositHandler()
+				depositHandler.RegisterDepositHandler(substrate.FungibleTransfer, substrateListener.FungibleTransferHandler)
+				eventHandlers := make([]coreSubstrateListener.EventHandler, 0)
+				eventHandlers = append(eventHandlers, substrateListener.NewFungibleTransferEventHandler(l, *config.GeneralChainConfig.Id, depositHandler, make(chan []*message.Message, 1), conn))
+				eventHandlers = append(eventHandlers, substrateListener.NewRetryEventHandler(l, conn, depositHandler, *config.GeneralChainConfig.Id, make(chan []*message.Message, 1)))
 
-				substrateListener := core_substrate_listener.NewSubstrateListener(conn, eventHandlers, blockstore, sygmaMetrics, *config.GeneralChainConfig.Id, config.BlockRetryInterval, config.BlockInterval)
+				substrateListener := coreSubstrateListener.NewSubstrateListener(conn, eventHandlers, blockstore, sygmaMetrics, *config.GeneralChainConfig.Id, config.BlockRetryInterval, config.BlockInterval)
 
-				mh := coreMessage.NewMessageHandler()
+				mh := message.NewMessageHandler()
 				mh.RegisterMessageHandler(substrate.FungibleTransfer, &substrateExecutor.SubstrateMessageHandler{})
 
 				sExecutor := substrateExecutor.NewExecutor(host, communication, coordinator, bridgePallet, keyshareStore, conn, exitLock)
@@ -265,7 +262,7 @@ func Run() error {
 
 	r := relayer.NewRelayer(chains)
 
-	msgChan := make(chan []*coreMessage.Message)
+	msgChan := make(chan []*message.Message)
 	go r.Start(ctx, msgChan)
 
 	sysErr := make(chan os.Signal, 1)
diff --git a/chains/evm/calls/mock/calls.go b/chains/evm/calls/mock/calls.go
deleted file mode 100644
index 913f7478..00000000
--- a/chains/evm/calls/mock/calls.go
+++ /dev/null
@@ -1,486 +0,0 @@
-// Code generated by MockGen. DO NOT EDIT.
-// Source: chains/evm/calls/calls.go
-
-// Package mock_calls is a generated GoMock package.
-package mock_calls
-
-import (
-	context "context"
-	big "math/big"
-	reflect "reflect"
-
-	evmclient "github.com/ChainSafe/chainbridge-core/chains/evm/calls/evmclient"
-	common "github.com/ethereum/go-ethereum/common"
-	types "github.com/ethereum/go-ethereum/core/types"
-	gomock "github.com/golang/mock/gomock"
-)
-
-// MockContractChecker is a mock of ContractChecker interface.
-type MockContractChecker struct {
-	ctrl     *gomock.Controller
-	recorder *MockContractCheckerMockRecorder
-}
-
-// MockContractCheckerMockRecorder is the mock recorder for MockContractChecker.
-type MockContractCheckerMockRecorder struct {
-	mock *MockContractChecker
-}
-
-// NewMockContractChecker creates a new mock instance.
-func NewMockContractChecker(ctrl *gomock.Controller) *MockContractChecker {
-	mock := &MockContractChecker{ctrl: ctrl}
-	mock.recorder = &MockContractCheckerMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockContractChecker) EXPECT() *MockContractCheckerMockRecorder {
-	return m.recorder
-}
-
-// CodeAt mocks base method.
-func (m *MockContractChecker) CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CodeAt", ctx, contract, blockNumber)
-	ret0, _ := ret[0].([]byte)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CodeAt indicates an expected call of CodeAt.
-func (mr *MockContractCheckerMockRecorder) CodeAt(ctx, contract, blockNumber interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CodeAt", reflect.TypeOf((*MockContractChecker)(nil).CodeAt), ctx, contract, blockNumber)
-}
-
-// MockContractCaller is a mock of ContractCaller interface.
-type MockContractCaller struct {
-	ctrl     *gomock.Controller
-	recorder *MockContractCallerMockRecorder
-}
-
-// MockContractCallerMockRecorder is the mock recorder for MockContractCaller.
-type MockContractCallerMockRecorder struct {
-	mock *MockContractCaller
-}
-
-// NewMockContractCaller creates a new mock instance.
-func NewMockContractCaller(ctrl *gomock.Controller) *MockContractCaller {
-	mock := &MockContractCaller{ctrl: ctrl}
-	mock.recorder = &MockContractCallerMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockContractCaller) EXPECT() *MockContractCallerMockRecorder {
-	return m.recorder
-}
-
-// CallContract mocks base method.
-func (m *MockContractCaller) CallContract(ctx context.Context, callArgs map[string]interface{}, blockNumber *big.Int) ([]byte, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CallContract", ctx, callArgs, blockNumber)
-	ret0, _ := ret[0].([]byte)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CallContract indicates an expected call of CallContract.
-func (mr *MockContractCallerMockRecorder) CallContract(ctx, callArgs, blockNumber interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallContract", reflect.TypeOf((*MockContractCaller)(nil).CallContract), ctx, callArgs, blockNumber)
-}
-
-// MockGasPricer is a mock of GasPricer interface.
-type MockGasPricer struct {
-	ctrl     *gomock.Controller
-	recorder *MockGasPricerMockRecorder
-}
-
-// MockGasPricerMockRecorder is the mock recorder for MockGasPricer.
-type MockGasPricerMockRecorder struct {
-	mock *MockGasPricer
-}
-
-// NewMockGasPricer creates a new mock instance.
-func NewMockGasPricer(ctrl *gomock.Controller) *MockGasPricer {
-	mock := &MockGasPricer{ctrl: ctrl}
-	mock.recorder = &MockGasPricerMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockGasPricer) EXPECT() *MockGasPricerMockRecorder {
-	return m.recorder
-}
-
-// GasPrice mocks base method.
-func (m *MockGasPricer) GasPrice(priority *uint8) ([]*big.Int, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GasPrice", priority)
-	ret0, _ := ret[0].([]*big.Int)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GasPrice indicates an expected call of GasPrice.
-func (mr *MockGasPricerMockRecorder) GasPrice(priority interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GasPrice", reflect.TypeOf((*MockGasPricer)(nil).GasPrice), priority)
-}
-
-// MockClientDispatcher is a mock of ClientDispatcher interface.
-type MockClientDispatcher struct {
-	ctrl     *gomock.Controller
-	recorder *MockClientDispatcherMockRecorder
-}
-
-// MockClientDispatcherMockRecorder is the mock recorder for MockClientDispatcher.
-type MockClientDispatcherMockRecorder struct {
-	mock *MockClientDispatcher
-}
-
-// NewMockClientDispatcher creates a new mock instance.
-func NewMockClientDispatcher(ctrl *gomock.Controller) *MockClientDispatcher {
-	mock := &MockClientDispatcher{ctrl: ctrl}
-	mock.recorder = &MockClientDispatcherMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockClientDispatcher) EXPECT() *MockClientDispatcherMockRecorder {
-	return m.recorder
-}
-
-// From mocks base method.
-func (m *MockClientDispatcher) From() common.Address {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "From")
-	ret0, _ := ret[0].(common.Address)
-	return ret0
-}
-
-// From indicates an expected call of From.
-func (mr *MockClientDispatcherMockRecorder) From() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "From", reflect.TypeOf((*MockClientDispatcher)(nil).From))
-}
-
-// GetTransactionByHash mocks base method.
-func (m *MockClientDispatcher) GetTransactionByHash(h common.Hash) (*types.Transaction, bool, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTransactionByHash", h)
-	ret0, _ := ret[0].(*types.Transaction)
-	ret1, _ := ret[1].(bool)
-	ret2, _ := ret[2].(error)
-	return ret0, ret1, ret2
-}
-
-// GetTransactionByHash indicates an expected call of GetTransactionByHash.
-func (mr *MockClientDispatcherMockRecorder) GetTransactionByHash(h interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransactionByHash", reflect.TypeOf((*MockClientDispatcher)(nil).GetTransactionByHash), h)
-}
-
-// LockNonce mocks base method.
-func (m *MockClientDispatcher) LockNonce() {
-	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "LockNonce")
-}
-
-// LockNonce indicates an expected call of LockNonce.
-func (mr *MockClientDispatcherMockRecorder) LockNonce() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LockNonce", reflect.TypeOf((*MockClientDispatcher)(nil).LockNonce))
-}
-
-// SignAndSendTransaction mocks base method.
-func (m *MockClientDispatcher) SignAndSendTransaction(ctx context.Context, tx evmclient.CommonTransaction) (common.Hash, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SignAndSendTransaction", ctx, tx)
-	ret0, _ := ret[0].(common.Hash)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SignAndSendTransaction indicates an expected call of SignAndSendTransaction.
-func (mr *MockClientDispatcherMockRecorder) SignAndSendTransaction(ctx, tx interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignAndSendTransaction", reflect.TypeOf((*MockClientDispatcher)(nil).SignAndSendTransaction), ctx, tx)
-}
-
-// UnlockNonce mocks base method.
-func (m *MockClientDispatcher) UnlockNonce() {
-	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "UnlockNonce")
-}
-
-// UnlockNonce indicates an expected call of UnlockNonce.
-func (mr *MockClientDispatcherMockRecorder) UnlockNonce() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnlockNonce", reflect.TypeOf((*MockClientDispatcher)(nil).UnlockNonce))
-}
-
-// UnsafeIncreaseNonce mocks base method.
-func (m *MockClientDispatcher) UnsafeIncreaseNonce() error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UnsafeIncreaseNonce")
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// UnsafeIncreaseNonce indicates an expected call of UnsafeIncreaseNonce.
-func (mr *MockClientDispatcherMockRecorder) UnsafeIncreaseNonce() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnsafeIncreaseNonce", reflect.TypeOf((*MockClientDispatcher)(nil).UnsafeIncreaseNonce))
-}
-
-// UnsafeNonce mocks base method.
-func (m *MockClientDispatcher) UnsafeNonce() (*big.Int, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UnsafeNonce")
-	ret0, _ := ret[0].(*big.Int)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UnsafeNonce indicates an expected call of UnsafeNonce.
-func (mr *MockClientDispatcherMockRecorder) UnsafeNonce() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnsafeNonce", reflect.TypeOf((*MockClientDispatcher)(nil).UnsafeNonce))
-}
-
-// WaitAndReturnTxReceipt mocks base method.
-func (m *MockClientDispatcher) WaitAndReturnTxReceipt(h common.Hash) (*types.Receipt, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitAndReturnTxReceipt", h)
-	ret0, _ := ret[0].(*types.Receipt)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// WaitAndReturnTxReceipt indicates an expected call of WaitAndReturnTxReceipt.
-func (mr *MockClientDispatcherMockRecorder) WaitAndReturnTxReceipt(h interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitAndReturnTxReceipt", reflect.TypeOf((*MockClientDispatcher)(nil).WaitAndReturnTxReceipt), h)
-}
-
-// MockContractCallerDispatcher is a mock of ContractCallerDispatcher interface.
-type MockContractCallerDispatcher struct {
-	ctrl     *gomock.Controller
-	recorder *MockContractCallerDispatcherMockRecorder
-}
-
-// MockContractCallerDispatcherMockRecorder is the mock recorder for MockContractCallerDispatcher.
-type MockContractCallerDispatcherMockRecorder struct {
-	mock *MockContractCallerDispatcher
-}
-
-// NewMockContractCallerDispatcher creates a new mock instance.
-func NewMockContractCallerDispatcher(ctrl *gomock.Controller) *MockContractCallerDispatcher {
-	mock := &MockContractCallerDispatcher{ctrl: ctrl}
-	mock.recorder = &MockContractCallerDispatcherMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockContractCallerDispatcher) EXPECT() *MockContractCallerDispatcherMockRecorder {
-	return m.recorder
-}
-
-// CallContract mocks base method.
-func (m *MockContractCallerDispatcher) CallContract(ctx context.Context, callArgs map[string]interface{}, blockNumber *big.Int) ([]byte, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CallContract", ctx, callArgs, blockNumber)
-	ret0, _ := ret[0].([]byte)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CallContract indicates an expected call of CallContract.
-func (mr *MockContractCallerDispatcherMockRecorder) CallContract(ctx, callArgs, blockNumber interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallContract", reflect.TypeOf((*MockContractCallerDispatcher)(nil).CallContract), ctx, callArgs, blockNumber)
-}
-
-// CodeAt mocks base method.
-func (m *MockContractCallerDispatcher) CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CodeAt", ctx, contract, blockNumber)
-	ret0, _ := ret[0].([]byte)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CodeAt indicates an expected call of CodeAt.
-func (mr *MockContractCallerDispatcherMockRecorder) CodeAt(ctx, contract, blockNumber interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CodeAt", reflect.TypeOf((*MockContractCallerDispatcher)(nil).CodeAt), ctx, contract, blockNumber)
-}
-
-// From mocks base method.
-func (m *MockContractCallerDispatcher) From() common.Address {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "From")
-	ret0, _ := ret[0].(common.Address)
-	return ret0
-}
-
-// From indicates an expected call of From.
-func (mr *MockContractCallerDispatcherMockRecorder) From() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "From", reflect.TypeOf((*MockContractCallerDispatcher)(nil).From))
-}
-
-// GetTransactionByHash mocks base method.
-func (m *MockContractCallerDispatcher) GetTransactionByHash(h common.Hash) (*types.Transaction, bool, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetTransactionByHash", h)
-	ret0, _ := ret[0].(*types.Transaction)
-	ret1, _ := ret[1].(bool)
-	ret2, _ := ret[2].(error)
-	return ret0, ret1, ret2
-}
-
-// GetTransactionByHash indicates an expected call of GetTransactionByHash.
-func (mr *MockContractCallerDispatcherMockRecorder) GetTransactionByHash(h interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransactionByHash", reflect.TypeOf((*MockContractCallerDispatcher)(nil).GetTransactionByHash), h)
-}
-
-// LockNonce mocks base method.
-func (m *MockContractCallerDispatcher) LockNonce() {
-	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "LockNonce")
-}
-
-// LockNonce indicates an expected call of LockNonce.
-func (mr *MockContractCallerDispatcherMockRecorder) LockNonce() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LockNonce", reflect.TypeOf((*MockContractCallerDispatcher)(nil).LockNonce))
-}
-
-// SignAndSendTransaction mocks base method.
-func (m *MockContractCallerDispatcher) SignAndSendTransaction(ctx context.Context, tx evmclient.CommonTransaction) (common.Hash, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SignAndSendTransaction", ctx, tx)
-	ret0, _ := ret[0].(common.Hash)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// SignAndSendTransaction indicates an expected call of SignAndSendTransaction.
-func (mr *MockContractCallerDispatcherMockRecorder) SignAndSendTransaction(ctx, tx interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignAndSendTransaction", reflect.TypeOf((*MockContractCallerDispatcher)(nil).SignAndSendTransaction), ctx, tx)
-}
-
-// UnlockNonce mocks base method.
-func (m *MockContractCallerDispatcher) UnlockNonce() {
-	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "UnlockNonce")
-}
-
-// UnlockNonce indicates an expected call of UnlockNonce.
-func (mr *MockContractCallerDispatcherMockRecorder) UnlockNonce() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnlockNonce", reflect.TypeOf((*MockContractCallerDispatcher)(nil).UnlockNonce))
-}
-
-// UnsafeIncreaseNonce mocks base method.
-func (m *MockContractCallerDispatcher) UnsafeIncreaseNonce() error {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UnsafeIncreaseNonce")
-	ret0, _ := ret[0].(error)
-	return ret0
-}
-
-// UnsafeIncreaseNonce indicates an expected call of UnsafeIncreaseNonce.
-func (mr *MockContractCallerDispatcherMockRecorder) UnsafeIncreaseNonce() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnsafeIncreaseNonce", reflect.TypeOf((*MockContractCallerDispatcher)(nil).UnsafeIncreaseNonce))
-}
-
-// UnsafeNonce mocks base method.
-func (m *MockContractCallerDispatcher) UnsafeNonce() (*big.Int, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "UnsafeNonce")
-	ret0, _ := ret[0].(*big.Int)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UnsafeNonce indicates an expected call of UnsafeNonce.
-func (mr *MockContractCallerDispatcherMockRecorder) UnsafeNonce() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnsafeNonce", reflect.TypeOf((*MockContractCallerDispatcher)(nil).UnsafeNonce))
-}
-
-// WaitAndReturnTxReceipt mocks base method.
-func (m *MockContractCallerDispatcher) WaitAndReturnTxReceipt(h common.Hash) (*types.Receipt, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "WaitAndReturnTxReceipt", h)
-	ret0, _ := ret[0].(*types.Receipt)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// WaitAndReturnTxReceipt indicates an expected call of WaitAndReturnTxReceipt.
-func (mr *MockContractCallerDispatcherMockRecorder) WaitAndReturnTxReceipt(h interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitAndReturnTxReceipt", reflect.TypeOf((*MockContractCallerDispatcher)(nil).WaitAndReturnTxReceipt), h)
-}
-
-// MockSimulateCaller is a mock of SimulateCaller interface.
-type MockSimulateCaller struct {
-	ctrl     *gomock.Controller
-	recorder *MockSimulateCallerMockRecorder
-}
-
-// MockSimulateCallerMockRecorder is the mock recorder for MockSimulateCaller.
-type MockSimulateCallerMockRecorder struct {
-	mock *MockSimulateCaller
-}
-
-// NewMockSimulateCaller creates a new mock instance.
-func NewMockSimulateCaller(ctrl *gomock.Controller) *MockSimulateCaller {
-	mock := &MockSimulateCaller{ctrl: ctrl}
-	mock.recorder = &MockSimulateCallerMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockSimulateCaller) EXPECT() *MockSimulateCallerMockRecorder {
-	return m.recorder
-}
-
-// CallContract mocks base method.
-func (m *MockSimulateCaller) CallContract(ctx context.Context, callArgs map[string]interface{}, blockNumber *big.Int) ([]byte, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CallContract", ctx, callArgs, blockNumber)
-	ret0, _ := ret[0].([]byte)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// CallContract indicates an expected call of CallContract.
-func (mr *MockSimulateCallerMockRecorder) CallContract(ctx, callArgs, blockNumber interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CallContract", reflect.TypeOf((*MockSimulateCaller)(nil).CallContract), ctx, callArgs, blockNumber)
-}
-
-// TransactionByHash mocks base method.
-func (m *MockSimulateCaller) TransactionByHash(ctx context.Context, hash common.Hash) (*types.Transaction, bool, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "TransactionByHash", ctx, hash)
-	ret0, _ := ret[0].(*types.Transaction)
-	ret1, _ := ret[1].(bool)
-	ret2, _ := ret[2].(error)
-	return ret0, ret1, ret2
-}
-
-// TransactionByHash indicates an expected call of TransactionByHash.
-func (mr *MockSimulateCallerMockRecorder) TransactionByHash(ctx, hash interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionByHash", reflect.TypeOf((*MockSimulateCaller)(nil).TransactionByHash), ctx, hash)
-}
diff --git a/chains/evm/calls/util/util.go b/chains/evm/calls/util/util.go
deleted file mode 100644
index f67f39b5..00000000
--- a/chains/evm/calls/util/util.go
+++ /dev/null
@@ -1,10 +0,0 @@
-// The Licensed Work is (c) 2022 Sygma
-// SPDX-License-Identifier: LGPL-3.0-only
-
-package util
-
-func SliceTo4Bytes(in []byte) [4]byte {
-	var res [4]byte
-	copy(res[:], in)
-	return res
-}
diff --git a/chains/evm/chain.go b/chains/evm/chain.go
deleted file mode 100644
index a9b3650a..00000000
--- a/chains/evm/chain.go
+++ /dev/null
@@ -1,103 +0,0 @@
-// The Licensed Work is (c) 2022 Sygma
-// SPDX-License-Identifier: LGPL-3.0-only
-
-package evm
-
-import (
-	"context"
-	"fmt"
-	"math/big"
-
-	"github.com/ChainSafe/chainbridge-core/chains/evm"
-	"github.com/ChainSafe/chainbridge-core/chains/evm/calls/evmclient"
-	"github.com/ChainSafe/chainbridge-core/relayer/message"
-	"github.com/ChainSafe/chainbridge-core/store"
-	"github.com/ChainSafe/sygma-relayer/chains"
-	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
-)
-
-type BatchProposalExecutor interface {
-	Execute(msgs []*message.Message) error
-}
-
-type EVMChain struct {
-	client        *evmclient.EVMClient
-	listener      evm.EventListener
-	executor      BatchProposalExecutor
-	blockstore    *store.BlockStore
-	domainID      uint8
-	startBlock    *big.Int
-	blockInterval *big.Int
-	freshStart    bool
-	latestBlock   bool
-	logger        zerolog.Logger
-}
-
-func NewEVMChain(
-	client *evmclient.EVMClient, listener evm.EventListener, executor BatchProposalExecutor,
-	blockstore *store.BlockStore, domainID uint8, startBlock *big.Int, blockInterval *big.Int,
-	freshStart bool, latestBlock bool,
-) *EVMChain {
-	return &EVMChain{
-		client:        client,
-		listener:      listener,
-		executor:      executor,
-		blockstore:    blockstore,
-		domainID:      domainID,
-		startBlock:    startBlock,
-		blockInterval: blockInterval,
-		freshStart:    freshStart,
-		latestBlock:   latestBlock,
-		logger:        log.With().Uint8("domainID", domainID).Logger(),
-	}
-}
-
-func (c *EVMChain) Write(msgs []*message.Message) error {
-	err := c.executor.Execute(msgs)
-	if err != nil {
-		log.Err(err).Str("domainID", string(c.domainID)).Msgf("error writing messages %+v", msgs)
-		return err
-	}
-
-	return nil
-}
-
-func (c *EVMChain) PollEvents(ctx context.Context, sysErr chan<- error, msgChan chan []*message.Message) {
-	c.logger.Info().Msg("Polling Blocks...")
-
-	startBlock, err := c.blockstore.GetStartBlock(
-		c.domainID,
-		c.startBlock,
-		c.latestBlock,
-		c.freshStart,
-	)
-	if err != nil {
-		sysErr <- fmt.Errorf("error %w on getting last stored block for domain %d", err, c.domainID)
-		return
-	}
-
-	// start from latest
-	if startBlock == nil {
-		head, err := c.client.LatestBlock()
-		if err != nil {
-			sysErr <- fmt.Errorf("error %w on getting latest block for domain %d", err, c.domainID)
-			return
-		}
-		startBlock = head
-	}
-
-	startBlock, err = chains.CalculateStartingBlock(startBlock, c.blockInterval)
-	if err != nil {
-		sysErr <- fmt.Errorf("error %w on CalculateStartingBlock domain %d", err, c.domainID)
-		return
-	}
-
-	c.logger.Info().Msgf("Starting block: %s", startBlock.String())
-
-	go c.listener.ListenToEvents(ctx, startBlock, msgChan, sysErr)
-}
-
-func (c *EVMChain) DomainID() uint8 {
-	return c.domainID
-}
diff --git a/chains/evm/config.go b/chains/evm/config.go
index 26e85b17..af91ed45 100644
--- a/chains/evm/config.go
+++ b/chains/evm/config.go
@@ -12,8 +12,8 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/mitchellh/mapstructure"
 
-	"github.com/ChainSafe/chainbridge-core/config/chain"
-	"github.com/ChainSafe/chainbridge-core/crypto/secp256k1"
+	"github.com/ChainSafe/sygma-relayer/config/chain"
+	"github.com/sygmaprotocol/sygma-core/crypto/secp256k1"
 )
 
 type HandlerConfig struct {
diff --git a/chains/evm/config_test.go b/chains/evm/config_test.go
index 5c728e1b..a102dd2d 100644
--- a/chains/evm/config_test.go
+++ b/chains/evm/config_test.go
@@ -8,8 +8,8 @@ import (
 	"testing"
 	"time"
 
-	"github.com/ChainSafe/chainbridge-core/config/chain"
 	"github.com/ChainSafe/sygma-relayer/chains/evm"
+	"github.com/ChainSafe/sygma-relayer/config/chain"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/chains/evm/executor/message-handler_test.go b/chains/evm/executor/message-handler_test.go
index a02728e7..579dd95d 100644
--- a/chains/evm/executor/message-handler_test.go
+++ b/chains/evm/executor/message-handler_test.go
@@ -9,11 +9,10 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/ChainSafe/chainbridge-core/chains/evm/calls/events"
-
 	"github.com/sygmaprotocol/sygma-core/relayer/message"
 
 	"github.com/ChainSafe/sygma-relayer/chains"
+	"github.com/ChainSafe/sygma-relayer/chains/evm/calls/events"
 	"github.com/ChainSafe/sygma-relayer/chains/evm/executor"
 	"github.com/ChainSafe/sygma-relayer/e2e/evm"
 	"github.com/ethereum/go-ethereum/common"
diff --git a/chains/proposal.go b/chains/proposal.go
index 3b60249a..35577ee4 100644
--- a/chains/proposal.go
+++ b/chains/proposal.go
@@ -6,20 +6,17 @@ package chains
 import (
 	"fmt"
 
-	"github.com/ChainSafe/chainbridge-core/relayer/message"
-	"github.com/ChainSafe/chainbridge-core/types"
-	coreMessage "github.com/sygmaprotocol/sygma-core/relayer/message"
-
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/signer/core/apitypes"
+	"github.com/sygmaprotocol/sygma-core/relayer/message"
 	"github.com/sygmaprotocol/sygma-core/relayer/proposal"
 )
 
 const (
-	TransferProposalType proposal.ProposalType   = "Transfer"
-	TransferMessageType  coreMessage.MessageType = "Transfer"
+	TransferProposalType proposal.ProposalType = "Transfer"
+	TransferMessageType  message.MessageType   = "Transfer"
 )
 
 type TransferProposal struct {
@@ -63,15 +60,6 @@ func NewProposal(source uint8, destination uint8, data interface{}, propType pro
 	}
 }
 
-type Proposal struct {
-	OriginDomainID uint8            // Source domainID where message was initiated
-	DepositNonce   uint64           // Nonce for the deposit
-	ResourceID     types.ResourceID // change id -> ID
-	Data           []byte
-	Destination    uint8 // Destination domainID where message is to be sent
-	Metadata       message.Metadata
-}
-
 func ProposalsHash(proposals []*TransferProposal, chainID int64, verifContract string, bridgeVersion string) ([]byte, error) {
 
 	formattedProps := make([]interface{}, len(proposals))
@@ -143,7 +131,7 @@ type TransferMessage struct {
 	Source      uint8
 	Destination uint8
 	Data        TransferMessageData
-	Type        coreMessage.MessageType
+	Type        message.MessageType
 }
 
 type TransferMessageData struct {
@@ -153,9 +141,9 @@ type TransferMessageData struct {
 	Payload      []interface{}
 }
 
-func NewMessage(source, destination uint8, data interface{}, msgType coreMessage.MessageType) *coreMessage.Message {
+func NewMessage(source, destination uint8, data interface{}, msgType message.MessageType) *message.Message {
 
-	return &coreMessage.Message{
+	return &message.Message{
 		Source:      source,
 		Destination: destination,
 		Data:        data,
diff --git a/chains/substrate/config.go b/chains/substrate/config.go
index 96d10e1c..9da2549a 100644
--- a/chains/substrate/config.go
+++ b/chains/substrate/config.go
@@ -13,7 +13,7 @@ import (
 	"github.com/mitchellh/mapstructure"
 	"github.com/sygmaprotocol/sygma-core/relayer/message"
 
-	"github.com/ChainSafe/chainbridge-core/config/chain"
+	"github.com/ChainSafe/sygma-relayer/config/chain"
 )
 
 const (
diff --git a/chains/substrate/config_test.go b/chains/substrate/config_test.go
index 9811283b..068bb514 100644
--- a/chains/substrate/config_test.go
+++ b/chains/substrate/config_test.go
@@ -7,7 +7,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/ChainSafe/chainbridge-core/config/chain"
+	"github.com/ChainSafe/sygma-relayer/config/chain"
 	"github.com/stretchr/testify/suite"
 )
 
diff --git a/chains/substrate/executor/message-handler_test.go b/chains/substrate/executor/message-handler_test.go
index 0b788894..b9037342 100644
--- a/chains/substrate/executor/message-handler_test.go
+++ b/chains/substrate/executor/message-handler_test.go
@@ -10,14 +10,13 @@ import (
 	"unsafe"
 
 	"github.com/ChainSafe/sygma-relayer/chains"
+	substrateChain "github.com/ChainSafe/sygma-relayer/chains/substrate"
 	"github.com/ChainSafe/sygma-relayer/chains/substrate/executor"
 	"github.com/ChainSafe/sygma-relayer/e2e/substrate"
 	"github.com/centrifuge/go-substrate-rpc-client/v4/types"
 	"github.com/sygmaprotocol/sygma-core/relayer/message"
 	"github.com/sygmaprotocol/sygma-core/relayer/proposal"
 
-	substrate_chain "github.com/ChainSafe/sygma-relayer/chains/substrate"
-
 	"github.com/stretchr/testify/suite"
 )
 
@@ -49,7 +48,7 @@ func (s *FungibleTransferHandlerTestSuite) TestFungibleTransferHandleMessage() {
 			},
 		},
 
-		Type: substrate_chain.FungibleTransfer,
+		Type: substrateChain.FungibleTransfer,
 	}
 	data, _ := hex.DecodeString("0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000002400010100d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d")
 	expectedProp := &proposal.Proposal{
@@ -82,7 +81,7 @@ func (s *FungibleTransferHandlerTestSuite) TestFungibleTransferHandleMessageInco
 			},
 		},
 
-		Type: substrate_chain.FungibleTransfer,
+		Type: substrateChain.FungibleTransfer,
 	}
 
 	mh := executor.SubstrateMessageHandler{}
@@ -106,7 +105,7 @@ func (s *FungibleTransferHandlerTestSuite) TestFungibleTransferHandleMessageInco
 			},
 		},
 
-		Type: substrate_chain.FungibleTransfer,
+		Type: substrateChain.FungibleTransfer,
 	}
 
 	mh := executor.SubstrateMessageHandler{}
@@ -130,7 +129,7 @@ func (s *FungibleTransferHandlerTestSuite) TestFungibleTransferHandleMessageInco
 			},
 		},
 
-		Type: substrate_chain.FungibleTransfer,
+		Type: substrateChain.FungibleTransfer,
 	}
 
 	mh := executor.SubstrateMessageHandler{}
@@ -157,7 +156,7 @@ func (s *FungibleTransferHandlerTestSuite) TestSuccesfullyRegisterFungibleTransf
 			},
 		},
 
-		Type: substrate_chain.FungibleTransfer,
+		Type: substrateChain.FungibleTransfer,
 	}
 
 	invalidMessageData := &message.Message{
@@ -177,7 +176,7 @@ func (s *FungibleTransferHandlerTestSuite) TestSuccesfullyRegisterFungibleTransf
 
 	depositMessageHandler := message.NewMessageHandler()
 	// Register FungibleTransferMessageHandler function
-	depositMessageHandler.RegisterMessageHandler(substrate_chain.FungibleTransfer, &executor.SubstrateMessageHandler{})
+	depositMessageHandler.RegisterMessageHandler(substrateChain.FungibleTransfer, &executor.SubstrateMessageHandler{})
 	prop1, err1 := depositMessageHandler.HandleMessage(messageData)
 	s.Nil(err1)
 	s.NotNil(prop1)
diff --git a/chains/substrate/listener/deposit-handler_test.go b/chains/substrate/listener/deposit-handler_test.go
index 649cce27..1ecce000 100644
--- a/chains/substrate/listener/deposit-handler_test.go
+++ b/chains/substrate/listener/deposit-handler_test.go
@@ -15,7 +15,7 @@ import (
 	"testing"
 
 	"github.com/ChainSafe/sygma-relayer/chains"
-	substrate_chain "github.com/ChainSafe/sygma-relayer/chains/substrate"
+	substrateChain "github.com/ChainSafe/sygma-relayer/chains/substrate"
 	"github.com/ChainSafe/sygma-relayer/chains/substrate/events"
 	"github.com/ChainSafe/sygma-relayer/chains/substrate/listener"
 	"github.com/ChainSafe/sygma-relayer/e2e/substrate"
@@ -68,7 +68,7 @@ func (s *Erc20HandlerTestSuite) TestErc20HandleEvent() {
 				recipientAddressParsed,
 			},
 		},
-		Type: substrate_chain.FungibleTransfer,
+		Type: substrateChain.FungibleTransfer,
 	}
 
 	message, err := listener.FungibleTransferHandler(sourceID, depositLog.DestDomainID, depositLog.DepositNonce, depositLog.ResourceID, depositLog.CallData)
@@ -119,7 +119,7 @@ func (s *Erc20HandlerTestSuite) TestSuccesfullyRegisterFungibleTransferHandler()
 
 	depositHandler := listener.NewSubstrateDepositHandler()
 	// Register FungibleTransferHandler function
-	depositHandler.RegisterDepositHandler(substrate_chain.FungibleTransfer, listener.FungibleTransferHandler)
+	depositHandler.RegisterDepositHandler(substrateChain.FungibleTransfer, listener.FungibleTransferHandler)
 	message1, err1 := depositHandler.HandleDeposit(1, d1.DestDomainID, d1.DepositNonce, d1.ResourceID, d1.CallData, d1.TransferType)
 	s.Nil(err1)
 	s.NotNil(message1)
diff --git a/chains/util.go b/chains/util.go
deleted file mode 100644
index 29718ba8..00000000
--- a/chains/util.go
+++ /dev/null
@@ -1,19 +0,0 @@
-// The Licensed Work is (c) 2022 Sygma
-// SPDX-License-Identifier: LGPL-3.0-only
-
-package chains
-
-import (
-	"fmt"
-	"math/big"
-)
-
-// CalculateStartingBlock returns first block number (smaller or equal) that is dividable with block confirmations
-func CalculateStartingBlock(startBlock *big.Int, blockConfirmations *big.Int) (*big.Int, error) {
-	if startBlock == nil || blockConfirmations == nil {
-		return nil, fmt.Errorf("startBlock or blockConfirmations can not be nill when calculating CalculateStartingBlock")
-	}
-	mod := big.NewInt(0).Mod(startBlock, blockConfirmations)
-	startBlock.Sub(startBlock, mod)
-	return startBlock, nil
-}
diff --git a/chains/util_test.go b/chains/util_test.go
deleted file mode 100644
index b461429f..00000000
--- a/chains/util_test.go
+++ /dev/null
@@ -1,37 +0,0 @@
-// The Licensed Work is (c) 2022 Sygma
-// SPDX-License-Identifier: LGPL-3.0-only
-
-package chains
-
-import (
-	"math/big"
-	"testing"
-
-	"github.com/stretchr/testify/suite"
-)
-
-type UtilTestSuite struct {
-	suite.Suite
-}
-
-func TestRunNewEVMConfigTestSuite(t *testing.T) {
-	suite.Run(t, new(UtilTestSuite))
-}
-
-func (s *UtilTestSuite) Test_CalculateStartingBlock_ProperAdjustment() {
-	res, err := CalculateStartingBlock(big.NewInt(104), big.NewInt(5))
-	s.Equal(big.NewInt(100), res)
-	s.Nil(err)
-}
-
-func (s *UtilTestSuite) Test_CalculateStartingBlock_NoAdjustment() {
-	res, err := CalculateStartingBlock(big.NewInt(200), big.NewInt(5))
-	s.Equal(big.NewInt(200), res)
-	s.Nil(err)
-}
-
-func (s *UtilTestSuite) Test_CalculateStartingBlock_Nil() {
-	res, err := CalculateStartingBlock(nil, nil)
-	s.Nil(res)
-	s.NotNil(err)
-}
diff --git a/cli/cli.go b/cli/cli.go
index 1ecdaca7..4a50d3de 100644
--- a/cli/cli.go
+++ b/cli/cli.go
@@ -8,10 +8,10 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 
-	"github.com/ChainSafe/chainbridge-core/flags"
 	"github.com/ChainSafe/sygma-relayer/cli/peer"
 	"github.com/ChainSafe/sygma-relayer/cli/topology"
 	"github.com/ChainSafe/sygma-relayer/cli/utils"
+	"github.com/ChainSafe/sygma-relayer/config"
 )
 
 var (
@@ -21,7 +21,7 @@ var (
 )
 
 func init() {
-	flags.BindFlags(rootCMD)
+	config.BindFlags(rootCMD)
 	rootCMD.PersistentFlags().String("name", "", "relayer name")
 	_ = viper.BindPFlag("name", rootCMD.PersistentFlags().Lookup("name"))
 
diff --git a/config/chain/config.go b/config/chain/config.go
new file mode 100644
index 00000000..905cfff5
--- /dev/null
+++ b/config/chain/config.go
@@ -0,0 +1,49 @@
+package chain
+
+import (
+	"fmt"
+
+	"github.com/ChainSafe/sygma-relayer/config"
+	"github.com/spf13/viper"
+)
+
+type GeneralChainConfig struct {
+	Name           string `mapstructure:"name"`
+	Id             *uint8 `mapstructure:"id"`
+	Endpoint       string `mapstructure:"endpoint"`
+	Type           string `mapstructure:"type"`
+	BlockstorePath string `mapstructure:"blockstorePath"`
+	FreshStart     bool   `mapstructure:"fresh"`
+	LatestBlock    bool   `mapstructure:"latest"`
+	Key            string
+	Insecure       bool
+}
+
+func (c *GeneralChainConfig) Validate() error {
+	// viper defaults to 0 for not specified ints
+	if c.Id == nil {
+		return fmt.Errorf("required field domain.Id empty for chain %v", c.Id)
+	}
+	if c.Endpoint == "" {
+		return fmt.Errorf("required field chain.Endpoint empty for chain %v", *c.Id)
+	}
+	if c.Name == "" {
+		return fmt.Errorf("required field chain.Name empty for chain %v", *c.Id)
+	}
+	return nil
+}
+
+func (c *GeneralChainConfig) ParseFlags() {
+	blockstore := viper.GetString(config.BlockstoreFlagName)
+	if blockstore != "" {
+		c.BlockstorePath = blockstore
+	}
+	freshStart := viper.GetBool(config.FreshStartFlagName)
+	if freshStart {
+		c.FreshStart = freshStart
+	}
+	latestBlock := viper.GetBool(config.LatestBlockFlagName)
+	if latestBlock {
+		c.LatestBlock = latestBlock
+	}
+}
diff --git a/config/chain/config_test.go b/config/chain/config_test.go
new file mode 100644
index 00000000..b41fce20
--- /dev/null
+++ b/config/chain/config_test.go
@@ -0,0 +1,51 @@
+package chain
+
+import (
+	"testing"
+)
+
+func TestValidateConfig(t *testing.T) {
+	var id uint8 = 1
+	valid := GeneralChainConfig{
+		Name:     "chain",
+		Id:       &id,
+		Endpoint: "endpoint",
+	}
+
+	missingEndpoint := GeneralChainConfig{
+		Name:     "chain",
+		Id:       &id,
+		Endpoint: "",
+	}
+
+	missingName := GeneralChainConfig{
+		Name:     "",
+		Id:       &id,
+		Endpoint: "endpoint",
+	}
+
+	missingId := GeneralChainConfig{
+		Name:     "chain",
+		Endpoint: "endpoint",
+	}
+
+	err := valid.Validate()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = missingEndpoint.Validate()
+	if err == nil {
+		t.Fatalf("must require endpoint field, %v", err)
+	}
+
+	err = missingName.Validate()
+	if err == nil {
+		t.Fatal("must require name field")
+	}
+
+	err = missingId.Validate()
+	if err == nil {
+		t.Fatalf("must require domain id field, %v", err)
+	}
+}
diff --git a/config/config.go b/config/config.go
index eeb153a4..e7d3c576 100644
--- a/config/config.go
+++ b/config/config.go
@@ -9,10 +9,11 @@ import (
 	"io"
 	"net/http"
 
+	"github.com/ChainSafe/sygma-relayer/config/relayer"
 	"github.com/creasty/defaults"
 	"github.com/imdario/mergo"
 
-	"github.com/ChainSafe/sygma-relayer/config/relayer"
+	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
 
@@ -116,3 +117,29 @@ func processRawConfig(rawConfig RawConfig, config *Config) (*Config, error) {
 	config.RelayerConfig = relayerConfig
 	return config, nil
 }
+
+var (
+	// Flags for running the app
+	ConfigFlagName      = "config"
+	KeystoreFlagName    = "keystore"
+	BlockstoreFlagName  = "blockstore"
+	FreshStartFlagName  = "fresh"
+	LatestBlockFlagName = "latest"
+)
+
+func BindFlags(rootCMD *cobra.Command) {
+	rootCMD.PersistentFlags().String(ConfigFlagName, ".", "Path to JSON configuration file")
+	_ = viper.BindPFlag(ConfigFlagName, rootCMD.PersistentFlags().Lookup(ConfigFlagName))
+
+	rootCMD.PersistentFlags().String(BlockstoreFlagName, "./lvldbdata", "Specify path for blockstore")
+	_ = viper.BindPFlag(BlockstoreFlagName, rootCMD.PersistentFlags().Lookup(BlockstoreFlagName))
+
+	rootCMD.PersistentFlags().Bool(FreshStartFlagName, false, "Disables loading from blockstore at start. Opts will still be used if specified. (default: false)")
+	_ = viper.BindPFlag(FreshStartFlagName, rootCMD.PersistentFlags().Lookup(FreshStartFlagName))
+
+	rootCMD.PersistentFlags().Bool(LatestBlockFlagName, false, "Overrides blockstore and start block, starts from latest block (default: false)")
+	_ = viper.BindPFlag(LatestBlockFlagName, rootCMD.PersistentFlags().Lookup(LatestBlockFlagName))
+
+	rootCMD.PersistentFlags().String(KeystoreFlagName, "./keys", "Path to keystore directory")
+	_ = viper.BindPFlag(KeystoreFlagName, rootCMD.PersistentFlags().Lookup(KeystoreFlagName))
+}
diff --git a/config/config_test.go b/config/config_test.go
index c3fb8106..b5fdf6c8 100644
--- a/config/config_test.go
+++ b/config/config_test.go
@@ -9,8 +9,6 @@ import (
 	"testing"
 	"time"
 
-	coreRelayer "github.com/ChainSafe/chainbridge-core/config/relayer"
-
 	"github.com/ChainSafe/sygma-relayer/config"
 	"github.com/ChainSafe/sygma-relayer/config/relayer"
 	"github.com/stretchr/testify/suite"
@@ -86,10 +84,8 @@ func (s *GetConfigTestSuite) Test_GetConfigFromENV() {
 
 	s.Equal(config.Config{
 		RelayerConfig: relayer.RelayerConfig{
-			RelayerConfig: coreRelayer.RelayerConfig{
-				LogLevel: 1,
-				LogFile:  "out.log",
-			},
+			LogLevel:   1,
+			LogFile:    "out.log",
 			Env:        "TEST",
 			Id:         "123",
 			HealthPort: 9001,
@@ -193,10 +189,8 @@ func (s *GetConfigTestSuite) Test_SharedConfigLengthMismatch() {
 
 	s.Equal(config.Config{
 		RelayerConfig: relayer.RelayerConfig{
-			RelayerConfig: coreRelayer.RelayerConfig{
-				LogLevel: 1,
-				LogFile:  "out.log",
-			},
+			LogLevel:   1,
+			LogFile:    "out.log",
 			HealthPort: 9001,
 			MpcConfig: relayer.MpcRelayerConfig{
 				TopologyConfiguration: relayer.TopologyConfiguration{
@@ -266,11 +260,9 @@ func (s *GetConfigTestSuite) Test_GetConfigFromFile() {
 					"name": "chain1",
 				}},
 				RelayerConfig: relayer.RawRelayerConfig{
-					RawRelayerConfig: coreRelayer.RawRelayerConfig{
-						OpenTelemetryCollectorURL: "",
-						LogLevel:                  "",
-						LogFile:                   "",
-					},
+					OpenTelemetryCollectorURL: "",
+					LogLevel:                  "",
+					LogFile:                   "",
 					MpcConfig: relayer.RawMpcRelayerConfig{
 						Port: "2020",
 						TopologyConfiguration: relayer.TopologyConfiguration{
@@ -295,9 +287,7 @@ func (s *GetConfigTestSuite) Test_GetConfigFromFile() {
 			name: "invalid relayer type",
 			inConfig: config.RawConfig{
 				RelayerConfig: relayer.RawRelayerConfig{
-					RawRelayerConfig: coreRelayer.RawRelayerConfig{
-						LogLevel: "invalid",
-					},
+					LogLevel: "invalid",
 					MpcConfig: relayer.RawMpcRelayerConfig{
 						TopologyConfiguration: relayer.TopologyConfiguration{
 							EncryptionKey: "enc-key",
@@ -319,9 +309,7 @@ func (s *GetConfigTestSuite) Test_GetConfigFromFile() {
 			name: "invalid bully config",
 			inConfig: config.RawConfig{
 				RelayerConfig: relayer.RawRelayerConfig{
-					RawRelayerConfig: coreRelayer.RawRelayerConfig{
-						LogLevel: "info",
-					},
+					LogLevel: "info",
 					MpcConfig: relayer.RawMpcRelayerConfig{
 						TopologyConfiguration: relayer.TopologyConfiguration{
 							EncryptionKey: "enc-key",
@@ -350,9 +338,7 @@ func (s *GetConfigTestSuite) Test_GetConfigFromFile() {
 			name: "missing encryption key",
 			inConfig: config.RawConfig{
 				RelayerConfig: relayer.RawRelayerConfig{
-					RawRelayerConfig: coreRelayer.RawRelayerConfig{
-						LogLevel: "info",
-					},
+					LogLevel: "info",
 					MpcConfig: relayer.RawMpcRelayerConfig{
 						TopologyConfiguration: relayer.TopologyConfiguration{},
 						Port:                  "2020",
@@ -391,12 +377,10 @@ func (s *GetConfigTestSuite) Test_GetConfigFromFile() {
 			errorMsg:   "unable to parse bully ping wait time: time: unknown unit \"z\" in duration \"2z\"",
 			outConfig: config.Config{
 				RelayerConfig: relayer.RelayerConfig{
-					RelayerConfig: coreRelayer.RelayerConfig{
-						LogLevel:                  1,
-						LogFile:                   "out.log",
-						OpenTelemetryCollectorURL: "",
-					},
-					HealthPort: 9001,
+					LogLevel:                  1,
+					LogFile:                   "out.log",
+					OpenTelemetryCollectorURL: "",
+					HealthPort:                9001,
 					MpcConfig: relayer.MpcRelayerConfig{
 						Port: 9000,
 						TopologyConfiguration: relayer.TopologyConfiguration{
@@ -424,10 +408,8 @@ func (s *GetConfigTestSuite) Test_GetConfigFromFile() {
 			name: "valid config",
 			inConfig: config.RawConfig{
 				RelayerConfig: relayer.RawRelayerConfig{
-					RawRelayerConfig: coreRelayer.RawRelayerConfig{
-						LogLevel: "debug",
-						LogFile:  "custom.log",
-					},
+					LogLevel:   "debug",
+					LogFile:    "custom.log",
 					HealthPort: "9002",
 					MpcConfig: relayer.RawMpcRelayerConfig{
 						TopologyConfiguration: relayer.TopologyConfiguration{
@@ -457,12 +439,10 @@ func (s *GetConfigTestSuite) Test_GetConfigFromFile() {
 			errorMsg:   "unable to parse bully ping wait time: time: unknown unit \"z\" in duration \"2z\"",
 			outConfig: config.Config{
 				RelayerConfig: relayer.RelayerConfig{
-					RelayerConfig: coreRelayer.RelayerConfig{
-						LogLevel:                  0,
-						LogFile:                   "custom.log",
-						OpenTelemetryCollectorURL: "",
-					},
-					HealthPort: 9002,
+					LogLevel:                  0,
+					LogFile:                   "custom.log",
+					OpenTelemetryCollectorURL: "",
+					HealthPort:                9002,
 					MpcConfig: relayer.MpcRelayerConfig{
 						Port:         2020,
 						KeysharePath: "./share.key",
diff --git a/config/env_test.go b/config/env_test.go
index 9baa2ef6..78a4fe36 100644
--- a/config/env_test.go
+++ b/config/env_test.go
@@ -9,7 +9,6 @@ import (
 
 	"github.com/stretchr/testify/suite"
 
-	coreRelayer "github.com/ChainSafe/chainbridge-core/config/relayer"
 	"github.com/ChainSafe/sygma-relayer/config/relayer"
 )
 
@@ -55,14 +54,12 @@ func (s *LoadFromEnvTestSuite) Test_ValidRelayerConfig() {
 
 	s.Nil(err)
 	s.Equal(relayer.RawRelayerConfig{
-		RawRelayerConfig: coreRelayer.RawRelayerConfig{
-			OpenTelemetryCollectorURL: "test.opentelemetry.url",
-			LogLevel:                  "info",
-			LogFile:                   "test.log",
-		},
-		Id:         "123",
-		Env:        "TEST",
-		HealthPort: "4000",
+		OpenTelemetryCollectorURL: "test.opentelemetry.url",
+		LogLevel:                  "info",
+		LogFile:                   "test.log",
+		Id:                        "123",
+		Env:                       "TEST",
+		HealthPort:                "4000",
 		MpcConfig: relayer.RawMpcRelayerConfig{
 			KeysharePath: "/cfg/keyshares/0.keyshare",
 			Key:          "test-pk",
diff --git a/config/relayer/config.go b/config/relayer/config.go
index 160cf07e..155ae0f9 100644
--- a/config/relayer/config.go
+++ b/config/relayer/config.go
@@ -10,17 +10,17 @@ import (
 	"time"
 
 	"github.com/rs/zerolog"
-
-	"github.com/ChainSafe/chainbridge-core/config/relayer"
 )
 
 type RelayerConfig struct {
-	relayer.RelayerConfig
-	HealthPort  uint16
-	Env         string
-	Id          string
-	MpcConfig   MpcRelayerConfig
-	BullyConfig BullyConfig
+	OpenTelemetryCollectorURL string
+	LogLevel                  zerolog.Level
+	LogFile                   string
+	HealthPort                uint16
+	Env                       string
+	Id                        string
+	MpcConfig                 MpcRelayerConfig
+	BullyConfig               BullyConfig
 }
 
 type MpcRelayerConfig struct {
@@ -46,12 +46,14 @@ type TopologyConfiguration struct {
 }
 
 type RawRelayerConfig struct {
-	relayer.RawRelayerConfig `mapstructure:",squash"`
-	HealthPort               string              `mapstructure:"HealthPort" json:"healthPort" default:"9001"`
-	Env                      string              `mapstructure:"Env" json:"env"`
-	Id                       string              `mapstructure:"Id" json:"id"`
-	MpcConfig                RawMpcRelayerConfig `mapstructure:"MpcConfig" json:"mpcConfig"`
-	BullyConfig              RawBullyConfig      `mapstructure:"BullyConfig" json:"bullyConfig"`
+	OpenTelemetryCollectorURL string              `mapstructure:"OpenTelemetryCollectorURL" json:"opentelemetryCollectorURL"`
+	LogLevel                  string              `mapstructure:"LogLevel" json:"logLevel" default:"info"`
+	LogFile                   string              `mapstructure:"LogFile" json:"logFile" default:"out.log"`
+	HealthPort                string              `mapstructure:"HealthPort" json:"healthPort" default:"9001"`
+	Env                       string              `mapstructure:"Env" json:"env"`
+	Id                        string              `mapstructure:"Id" json:"id"`
+	MpcConfig                 RawMpcRelayerConfig `mapstructure:"MpcConfig" json:"mpcConfig"`
+	BullyConfig               RawBullyConfig      `mapstructure:"BullyConfig" json:"bullyConfig"`
 }
 
 type RawMpcRelayerConfig struct {
diff --git a/example/cmd/cmd.go b/example/cmd/cmd.go
index 6d4dca76..3089e30f 100644
--- a/example/cmd/cmd.go
+++ b/example/cmd/cmd.go
@@ -7,8 +7,7 @@ import (
 	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
 
-	"github.com/ChainSafe/chainbridge-core/flags"
-
+	"github.com/ChainSafe/sygma-relayer/config"
 	"github.com/ChainSafe/sygma-relayer/example/app"
 )
 
@@ -30,7 +29,7 @@ var (
 )
 
 func init() {
-	flags.BindFlags(runCMD)
+	config.BindFlags(runCMD)
 }
 
 func Execute() {
diff --git a/metrics/metrics.go b/metrics/metrics.go
index 213b1aaf..4e412cc5 100644
--- a/metrics/metrics.go
+++ b/metrics/metrics.go
@@ -6,14 +6,14 @@ package metrics
 import (
 	"context"
 
-	"github.com/ChainSafe/chainbridge-core/opentelemetry"
 	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/sygmaprotocol/sygma-core/observability"
 	"go.opentelemetry.io/otel/attribute"
 	api "go.opentelemetry.io/otel/metric"
 )
 
 type SygmaMetrics struct {
-	*opentelemetry.RelayerMetrics
+	*observability.RelayerMetrics
 
 	DepositErrorRate  api.Int64Counter
 	TotalRelayers     api.Int64ObservableGauge
@@ -26,7 +26,7 @@ type SygmaMetrics struct {
 
 // NewMetrics creates an instance of metrics
 func NewSygmaMetrics(meter api.Meter, env, relayerID string) (*SygmaMetrics, error) {
-	relayerMetrics, err := opentelemetry.NewRelayerMetrics(meter, attribute.String("relayerid", relayerID), attribute.String("env", env))
+	relayerMetrics, err := observability.NewRelayerMetrics(meter, attribute.String("relayerid", relayerID), attribute.String("env", env))
 	if err != nil {
 		return nil, err
 	}