some more cleanup

backend/cchain/config.go

@@ -3,50 +3,44 @@ package cchain
 import (
 	"math/big"
 
+	"github.com/ava-labs/avalanche-rosetta/constants"
 	ethtypes "github.com/ava-labs/coreth/core/types"
 	"github.com/coinbase/rosetta-sdk-go/types"
 )
 
 // Config holds the service configuration
 type Config struct {
-	Mode               string
+	Mode               constants.NodeMode
 	ChainID            *big.Int
 	NetworkID          *types.NetworkIdentifier
 	GenesisBlockHash   string
 	AvaxAssetID        string
-	IngestionMode      string
+	IngestionMode      constants.NodeIngestion
 	TokenWhiteList     []string
 	IndexUnknownTokens bool
 
 	// Upgrade Times
 	AP5Activation uint64
 }
 
-const (
-	ModeOffline        = "offline"
-	ModeOnline         = "online"
-	StandardIngestion  = "standard"
-	AnalyticsIngestion = "analytics"
-)
-
 // IsOfflineMode returns true if running in offline mode
 func (c Config) IsOfflineMode() bool {
-	return c.Mode == ModeOffline
+	return c.Mode == constants.Offline
 }
 
 // IsOnlineMode returns true if running in online mode
 func (c Config) IsOnlineMode() bool {
-	return c.Mode == ModeOnline
+	return c.Mode == constants.Online
 }
 
 // IsAnalyticsMode returns true if running in analytics ingestion mode
 func (c Config) IsAnalyticsMode() bool {
-	return c.IngestionMode == AnalyticsIngestion
+	return c.IngestionMode == constants.AnalyticsIngestion
 }
 
 // IsStandardMode returns true if running in standard ingestion mode
 func (c Config) IsStandardMode() bool {
-	return c.IngestionMode == StandardIngestion
+	return c.IngestionMode == constants.StandardIngestion
 }
 
 // IsTokenListEmpty returns true if the token addresses list is empty

backend/cchain/config_test.go

@@ -4,6 +4,7 @@ import (
 	"math/big"
 	"testing"
 
+	"github.com/ava-labs/avalanche-rosetta/constants"
 	ethtypes "github.com/ava-labs/coreth/core/types"
 	"github.com/coinbase/rosetta-sdk-go/types"
 	"github.com/stretchr/testify/assert"
@@ -12,7 +13,7 @@ import (
 func TestConfig(t *testing.T) {
 	t.Run("online", func(t *testing.T) {
 		cfg := Config{
-			Mode:      "online",
+			Mode:      constants.Online,
 			ChainID:   big.NewInt(1),
 			NetworkID: &types.NetworkIdentifier{},
 		}
@@ -23,7 +24,7 @@ func TestConfig(t *testing.T) {
 
 	t.Run("offline", func(t *testing.T) {
 		cfg := Config{
-			Mode:      "offline",
+			Mode:      constants.Offline,
 			ChainID:   big.NewInt(1),
 			NetworkID: &types.NetworkIdentifier{},
 		}

backend/pchain/account_test.go

@@ -48,7 +48,7 @@ func TestAccountBalance(t *testing.T) {
 	parserMock := &idxmocks.Parser{}
 	parserMock.Mock.On("GetGenesisBlock", ctx).Return(dummyGenesis, nil)
 	parserMock.Mock.On("ParseNonGenesisBlock", ctx, "", blockHeight).Return(parsedBlock, nil)
-	backend, err := NewBackend(constants.ModeOnline, pChainMock, parserMock, avaxAssetID, pChainNetworkIdentifier)
+	backend, err := NewBackend(constants.Online, pChainMock, parserMock, avaxAssetID, pChainNetworkIdentifier)
 	assert.Nil(t, err)
 	backend.getUTXOsPageSize = 2
 
@@ -209,7 +209,7 @@ func TestAccountCoins(t *testing.T) {
 	parserMock := &idxmocks.Parser{}
 	parserMock.Mock.On("GetGenesisBlock", ctx).Return(dummyGenesis, nil)
 	parserMock.Mock.On("ParseNonGenesisBlock", ctx, "", blockHeight).Return(parsedBlock, nil)
-	backend, err := NewBackend(constants.ModeOnline, pChainMock, parserMock, avaxAssetID, pChainNetworkIdentifier)
+	backend, err := NewBackend(constants.Online, pChainMock, parserMock, avaxAssetID, pChainNetworkIdentifier)
 	assert.Nil(t, err)
 
 	t.Run("Account Coins Test regular coins", func(t *testing.T) {

backend/pchain/backend.go

@@ -42,7 +42,7 @@ type Backend struct {
 
 // NewBackend creates a P-chain service backend
 func NewBackend(
-	nodeMode string,
+	nodeMode constants.NodeMode,
 	pClient client.PChainClient,
 	indexerParser indexer.Parser,
 	assetID ids.ID,
@@ -66,7 +66,7 @@ func NewBackend(
 		avaxAssetID:      assetID,
 	}
 
-	if nodeMode == constants.ModeOnline {
+	if nodeMode == constants.Online {
 		if err := backEnd.initChainIDs(); err != nil {
 			return nil, err
 		}

backend/pchain/backend_test.go

@@ -34,7 +34,7 @@ func TestShouldHandleRequest(t *testing.T) {
 	clientMock.Mock.On("GetBlockchainID", ctx, constants.XChain.String()).Return(ids.ID{'X'}, nil)
 	parserMock := &idxmocks.Parser{}
 	parserMock.Mock.On("GetGenesisBlock", ctx).Return(dummyGenesis, nil)
-	backend, err := NewBackend(constants.ModeOnline, clientMock, parserMock, avaxAssetID, pChainNetworkIdentifier)
+	backend, err := NewBackend(constants.Online, clientMock, parserMock, avaxAssetID, pChainNetworkIdentifier)
 	assert.Nil(t, err)
 
 	testData := []struct {

backend/pchain/construction.go

@@ -204,7 +204,7 @@ func (b *Backend) ConstructionParse(ctx context.Context, req *types.Construction
 		return nil, backend.WrapError(backend.ErrInvalidInput, err)
 	}
 
-	netID, _ := constants.FromString(rosettaTx.DestinationChain)
+	netID, _ := constants.GetChainIDAlias(rosettaTx.DestinationChain)
 	chainIDs := map[ids.ID]constants.ChainIDAlias{}
 	if rosettaTx.DestinationChainID != nil {
 		chainIDs[*rosettaTx.DestinationChainID] = netID

backend/pchain/construction_test.go

@@ -75,7 +75,7 @@ func TestConstructionDerive(t *testing.T) {
 	pChainMock.Mock.On("GetNetworkID", ctx).Return(uint32(5), nil)
 	parserMock := &idxmocks.Parser{}
 	parserMock.Mock.On("GetGenesisBlock", ctx).Return(dummyGenesis, nil)
-	backend, err := NewBackend(constants.ModeOnline, pChainMock, parserMock, avaxAssetID, pChainNetworkIdentifier)
+	backend, err := NewBackend(constants.Online, pChainMock, parserMock, avaxAssetID, pChainNetworkIdentifier)
 	assert.Nil(t, err)
 
 	t.Run("p-chain address", func(t *testing.T) {
@@ -188,7 +188,7 @@ func TestExportTxConstruction(t *testing.T) {
 	clientMock.Mock.On("GetBlockchainID", ctx, constants.XChain.String()).Return(ids.ID{'X'}, nil)
 	parserMock := &idxmocks.Parser{}
 	parserMock.Mock.On("GetGenesisBlock", ctx).Return(dummyGenesis, nil)
-	backend, err := NewBackend(constants.ModeOnline, clientMock, parserMock, avaxAssetID, pChainNetworkIdentifier)
+	backend, err := NewBackend(constants.Online, clientMock, parserMock, avaxAssetID, pChainNetworkIdentifier)
 	assert.Nil(t, err)
 
 	t.Run("preprocess endpoint", func(t *testing.T) {
@@ -404,7 +404,7 @@ func TestImportTxConstruction(t *testing.T) {
 	clientMock.Mock.On("GetBlockchainID", ctx, constants.XChain.String()).Return(ids.ID{'X'}, nil)
 	parserMock := &idxmocks.Parser{}
 	parserMock.Mock.On("GetGenesisBlock", ctx).Return(dummyGenesis, nil)
-	backend, err := NewBackend(constants.ModeOnline, clientMock, parserMock, avaxAssetID, pChainNetworkIdentifier)
+	backend, err := NewBackend(constants.Online, clientMock, parserMock, avaxAssetID, pChainNetworkIdentifier)
 	assert.Nil(t, err)
 
 	t.Run("preprocess endpoint", func(t *testing.T) {
@@ -643,7 +643,7 @@ func TestAddValidatorTxConstruction(t *testing.T) {
 	clientMock.Mock.On("GetBlockchainID", ctx, constants.XChain.String()).Return(ids.ID{'X'}, nil)
 	parserMock := &idxmocks.Parser{}
 	parserMock.Mock.On("GetGenesisBlock", ctx).Return(dummyGenesis, nil)
-	backend, err := NewBackend(constants.ModeOnline, clientMock, parserMock, avaxAssetID, pChainNetworkIdentifier)
+	backend, err := NewBackend(constants.Online, clientMock, parserMock, avaxAssetID, pChainNetworkIdentifier)
 	assert.Nil(t, err)
 
 	t.Run("preprocess endpoint", func(t *testing.T) {
@@ -877,7 +877,7 @@ func TestAddDelegatorTxConstruction(t *testing.T) {
 	clientMock.Mock.On("GetBlockchainID", ctx, constants.XChain.String()).Return(ids.ID{'X'}, nil)
 	parserMock := &idxmocks.Parser{}
 	parserMock.Mock.On("GetGenesisBlock", ctx).Return(dummyGenesis, nil)
-	backend, err := NewBackend(constants.ModeOnline, clientMock, parserMock, avaxAssetID, pChainNetworkIdentifier)
+	backend, err := NewBackend(constants.Online, clientMock, parserMock, avaxAssetID, pChainNetworkIdentifier)
 	assert.Nil(t, err)
 
 	t.Run("preprocess endpoint", func(t *testing.T) {

cmd/server/config.go

@@ -12,7 +12,6 @@ import (
 )
 
 var (
-	errInvalidMode             = errors.New("invalid rosetta mode")
 	errGenesisBlockRequired    = errors.New("genesis block hash is not provided")
 	errInvalidTokenAddress     = errors.New("invalid token address provided")
 	errInvalidErc20Address     = errors.New("not all token addresses provided are valid erc20s")
@@ -51,11 +50,11 @@ func readConfig(path string) (*config, error) {
 
 func (c *config) applyDefaults() {
 	if c.Mode == "" {
-		c.Mode = constants.ModeOnline
+		c.Mode = constants.Online.String()
 	}
 
 	if c.IngestionMode == "" {
-		c.IngestionMode = constants.StandardIngestion
+		c.IngestionMode = constants.StandardIngestion.String()
 	}
 
 	if c.RPCBaseURL == "" {
@@ -72,8 +71,8 @@ func (c *config) applyDefaults() {
 }
 
 func (c *config) validate() error {
-	if !(c.Mode == constants.ModeOffline || c.Mode == constants.ModeOnline) {
-		return errInvalidMode
+	if _, err := constants.GetNodeMode(c.Mode); err != nil {
+		return err
 	}
 
 	if c.GenesisBlockHash == "" {
@@ -88,11 +87,11 @@ func (c *config) validate() error {
 		}
 	}
 
-	if !(c.IngestionMode == constants.AnalyticsIngestion || c.IngestionMode == constants.StandardIngestion) {
-		return errInvalidIngestionMode
+	if _, err := constants.GetNodeIngestion(c.Mode); err != nil {
+		return err
 	}
 
-	if c.IngestionMode == constants.StandardIngestion && c.IndexUnknownTokens {
+	if c.IngestionMode == constants.StandardIngestion.String() && c.IndexUnknownTokens {
 		return errInvalidUnknownTokenMode
 	}
 	return nil

cmd/server/main.go

@@ -74,7 +74,7 @@ func main() {
 	// bootstrapping, it will fail.
 	//
 	// TODO: Only perform this check after the underlying node is bootstrapped
-	if cfg.Mode == constants.ModeOnline && cfg.ValidateERC20Whitelist {
+	if cfg.Mode == constants.Online.String() && cfg.ValidateERC20Whitelist {
 		if err := cfg.validateWhitelistOnlyValidErc20s(cChainClient); err != nil {
 			log.Fatal("token whitelist validation error:", err)
 		}
@@ -85,7 +85,7 @@ func main() {
 	if cfg.CChainID == 0 {
 		log.Println("chain id is not provided, fetching from rpc...")
 
-		if cfg.Mode == constants.ModeOffline {
+		if cfg.Mode == constants.Offline.String() {
 			log.Fatal("cant fetch chain id in offline mode")
 		}
 
@@ -131,15 +131,17 @@ func main() {
 	}
 
 	// Create C-chain backend
+	nodeMode, _ := constants.GetNodeMode(cfg.Mode)
+	ingestionMode, _ := constants.GetNodeIngestion(cfg.Mode)
 	cChainConfig := &cchain.Config{
-		Mode:               cfg.Mode,
+		Mode:               nodeMode,
 		ChainID:            big.NewInt(cfg.CChainID),
 		NetworkID:          networkC,
 		GenesisBlockHash:   cfg.GenesisBlockHash,
 		AvaxAssetID:        assetID,
 		AP5Activation:      AP5Activation,
 		IndexUnknownTokens: cfg.IndexUnknownTokens,
-		IngestionMode:      cfg.IngestionMode,
+		IngestionMode:      ingestionMode,
 		TokenWhiteList:     cfg.TokenWhiteList,
 	}
 	cChainBackend := cchain.NewBackend(cChainConfig, cChainClient)
@@ -150,7 +152,7 @@ func main() {
 	if err != nil {
 		log.Fatal("unable to initialize p-chain indexer parser:", err)
 	}
-	pChainBackend, err := pchain.NewBackend(cfg.Mode, pChainClient, pIndexerParser, avaxAssetID, networkP)
+	pChainBackend, err := pchain.NewBackend(nodeMode, pChainClient, pIndexerParser, avaxAssetID, networkP)
 	if err != nil {
 		log.Fatal("unable to initialize p-chain backend:", err)
 	}
@@ -177,7 +179,7 @@ func main() {
 	}
 
 	handler := configureRouter(
-		cfg.Mode,
+		nodeMode,
 		asserter,
 		cChainBackend,
 		pChainBackend,
@@ -203,7 +205,7 @@ func main() {
 }
 
 func validateNetworkName(cfg *config, cChainClient client.Client) error {
-	if cfg.Mode == constants.ModeOffline {
+	if cfg.Mode == constants.Offline.String() {
 		if cfg.NetworkName == "" {
 			return fmt.Errorf("network name is not provided, can't fetch network name in offline mode")
 		}
@@ -233,7 +235,7 @@ func validateNetworkName(cfg *config, cChainClient client.Client) error {
 }
 
 func configureRouter(
-	mode string,
+	mode constants.NodeMode,
 	asserter *asserter.Asserter,
 	cChainBackend *cchain.Backend,
 	pChainBackend *pchain.Backend,

constants/chain_id_aliases.go

@@ -27,7 +27,7 @@ func (ni ChainIDAlias) String() string {
 	}
 }
 
-func FromString(s string) (ChainIDAlias, error) {
+func GetChainIDAlias(s string) (ChainIDAlias, error) {
 	switch {
 	case s == "P":
 		return PChain, nil

constants/node.go

@@ -1,9 +1,68 @@
 package constants
 
-// TODO: consider turning these into enums
+import "errors"
+
+var (
+	ErrInvalidMode          = errors.New("invalid rosetta mode")
+	ErrInvalidIngestionMode = errors.New("invalid rosetta ingestion mode")
+)
+
+type NodeMode uint8
+
+const (
+	Unknown NodeMode = iota + 1
+	Offline
+	Online
+)
+
+func (m NodeMode) String() string {
+	switch m {
+	case Offline:
+		return "offline"
+	case Online:
+		return "online"
+	default:
+		return "unknown"
+	}
+}
+
+func GetNodeMode(s string) (NodeMode, error) {
+	switch {
+	case s == "offline":
+		return Offline, nil
+	case s == "online":
+		return Online, nil
+	default:
+		return Unknown, ErrInvalidMode
+	}
+}
+
+type NodeIngestion uint8
+
 const (
-	ModeOffline        = "offline"
-	ModeOnline         = "online"
-	StandardIngestion  = "standard"
-	AnalyticsIngestion = "analytics"
+	UnknownIngestion NodeIngestion = iota + 1
+	StandardIngestion
+	AnalyticsIngestion
 )
+
+func (m NodeIngestion) String() string {
+	switch m {
+	case StandardIngestion:
+		return "standard"
+	case AnalyticsIngestion:
+		return "analytics"
+	default:
+		return "unknown"
+	}
+}
+
+func GetNodeIngestion(s string) (NodeIngestion, error) {
+	switch {
+	case s == "standard":
+		return StandardIngestion, nil
+	case s == "analytics":
+		return AnalyticsIngestion, nil
+	default:
+		return UnknownIngestion, ErrInvalidIngestionMode
+	}
+}