fix(naming): sg->pol

Author: Devon Bear

README.md

@@ -6,8 +6,8 @@
 </h1>
 
 <div>
-  <a href="https://codecov.io/gh/berachain/stargazer" > 
-    <img src="https://codecov.io/gh/berachain/stargazer/branch/main/graph/badge.svg?token=0DYQAKBGVW"/> 
+  <a href="https://codecov.io/gh/berachain/polaris" > 
+    <img src="https://codecov.io/gh/berachain/polaris/branch/main/graph/badge.svg?token=0DYQAKBGVW"/> 
   </a>
   <a href="https://pkg.go.dev/pkg.berachain.dev/polaris">
     <img src="https://pkg.go.dev/badge/pkg.berachain.dev/polaris.svg" alt="Go Reference">
@@ -28,7 +28,7 @@
 
 ### From Binary
 
-The easiest way to install a Cosmos-SDK Blockchain running Polaris is to download a pre-built binary. You can find the latest binaries on the [releases](https://github.com/stargazer/releases) page.
+The easiest way to install a Cosmos-SDK Blockchain running Polaris is to download a pre-built binary. You can find the latest binaries on the [releases](https://github.com/polaris/releases) page.
 
 ### From Source
 
@@ -65,28 +65,28 @@ Go v1.20+ or higher is required for Polaris
 [Foundry](https://book.getfoundry.sh/getting-started/installation) is required for Polaris
 
 3. Install Foundry:
-
+polaris
    ```sh
    curl -L https://foundry.paradigm.xyz | bash
    ```
 
 **Step 2: Get Polaris source code**
 
-Clone the `stargazer` repo from the [official repo](https://github.com/berachain/stargazer/) and check
+Clone the `polaris` repo from the [official repo](https://github.com/berachain/polaris/) and check
 out the `main` branch for the latest stable release.
 Build the binary.
 
 ```bash
 cd $HOME
-git clone https://github.com/berachain/stargazer
-cd stargazer
+git clone https://github.com/berachain/polaris
+cd polaris
 git checkout main
 go run build/setup.go
 ```
 
 **Step 3: Build the Node Software**
 
-Run the following command to install `stargazerd` to your `GOPATH` and build the node. `stargazerd` is the node daemon and CLI for interacting with a stargazer node.
+Run the following command to install `polard` to your `GOPATH` and build the node. `polard` is the node daemon and CLI for interacting with a polaris node.
 
 ```bash
 mage install
@@ -97,14 +97,14 @@ mage install
 Verify your installation with the following command:
 
 ```bash
-stargazerd version --long
+polard version --long
 ```
 
 A successful installation will return the following:
 
 ```bash
 name: berachain
-server_name: stargazerd
+server_name: polard
 version: <x.x.x>
 commit: <Commit hash>
 build_tags: netgo,ledger

build/mage/build.go

@@ -66,7 +66,7 @@ func All() error {
 }
 
 func BuildPolarisApp() error {
-	cmd := "stargazerd"
+	cmd := "polard"
 	args := []string{
 		generateBuildTags(),
 		generateLinkerFlags(production, statically),
@@ -127,7 +127,7 @@ func Install() error {
 	args := []string{
 		generateBuildTags(),
 		generateLinkerFlags(production, statically),
-		"./runtime/cmd/stargazerd",
+		"./runtime/cmd/polard",
 	}
 
 	return goInstall(args...)

eth/rpc/backend.go

@@ -167,7 +167,7 @@ func (b *backend) SetHead(number uint64) {
 
 // `HeaderByNumber` returns the block header at the given block number.
 func (b *backend) HeaderByNumber(_ context.Context, number BlockNumber) (*types.Header, error) {
-	block, err := b.stargazerBlockByNumber(number)
+	block, err := b.polarisBlockByNumber(number)
 	if err != nil {
 		b.logger.Error("eth.rpc.backend.HeaderByNumber", "number", number, "err", err)
 		return nil, err
@@ -178,7 +178,7 @@ func (b *backend) HeaderByNumber(_ context.Context, number BlockNumber) (*types.
 
 // `HeaderByHash` returns the block header with the given hash.
 func (b *backend) HeaderByHash(_ context.Context, hash common.Hash) (*types.Header, error) {
-	block, err := b.stargazerBlockByHash(hash)
+	block, err := b.polarisBlockByHash(hash)
 	if err != nil {
 		b.logger.Error("eth.rpc.backend.HeaderByHash", "hash", hash, "err", err)
 		return nil, errorslib.Wrapf(ErrBlockNotFound, "HeaderByHash [%s]", hash.String())
@@ -191,7 +191,7 @@ func (b *backend) HeaderByHash(_ context.Context, hash common.Hash) (*types.Head
 func (b *backend) HeaderByNumberOrHash(_ context.Context,
 	blockNrOrHash BlockNumberOrHash,
 ) (*types.Header, error) {
-	block, err := b.stargazerBlockByNumberOrHash(blockNrOrHash)
+	block, err := b.polarisBlockByNumberOrHash(blockNrOrHash)
 	if err != nil {
 		b.logger.Error("eth.rpc.backend.HeaderByNumberOrHash", "blockNrOrHash", blockNrOrHash, "err", err)
 		return nil, err
@@ -225,7 +225,7 @@ func (b *backend) CurrentBlock() *types.Block {
 
 // `BlockByNumber` returns the block identified by `number`.
 func (b *backend) BlockByNumber(_ context.Context, number BlockNumber) (*types.Block, error) {
-	block, err := b.stargazerBlockByNumber(number)
+	block, err := b.polarisBlockByNumber(number)
 	if err != nil {
 		b.logger.Error("eth.rpc.backend.BlockByNumber", "number", number, "err", err)
 		return nil, errorslib.Wrapf(err, "BlockByNumber [%d]", number)
@@ -237,7 +237,7 @@ func (b *backend) BlockByNumber(_ context.Context, number BlockNumber) (*types.B
 
 // `BlockByHash` returns the block with the given `hash`.
 func (b *backend) BlockByHash(_ context.Context, hash common.Hash) (*types.Block, error) {
-	block, err := b.stargazerBlockByHash(hash)
+	block, err := b.polarisBlockByHash(hash)
 	b.logger.Info("BlockByHash", "hash", hash, "block", block)
 	if err != nil {
 		b.logger.Error("eth.rpc.backend.BlockByHash", "hash", hash, "err", err)
@@ -252,7 +252,7 @@ func (b *backend) BlockByHash(_ context.Context, hash common.Hash) (*types.Block
 func (b *backend) BlockByNumberOrHash(_ context.Context,
 	blockNrOrHash BlockNumberOrHash,
 ) (*types.Block, error) {
-	block, err := b.stargazerBlockByNumberOrHash(blockNrOrHash)
+	block, err := b.polarisBlockByNumberOrHash(blockNrOrHash)
 	if err != nil {
 		b.logger.Error("eth.rpc.backend.BlockByNumberOrHash", "blockNrOrHash", blockNrOrHash, "err", err)
 		return nil, err
@@ -270,7 +270,7 @@ func (b *backend) StateAndHeaderByNumber(
 		b.logger.Error("eth.rpc.backend.StateAndHeaderByNumber", "number", number, "err", err)
 		return nil, nil, err
 	}
-	block, err := b.stargazerBlockByNumber(number)
+	block, err := b.polarisBlockByNumber(number)
 	if err != nil {
 		b.logger.Error("eth.rpc.backend.StateAndHeaderByNumber", "number", number, "err", err)
 		return nil, nil, err
@@ -290,15 +290,15 @@ func (b *backend) StateAndHeaderByNumberOrHash(
 	if inputNum, ok := blockNrOrHash.Number(); ok {
 		// Try to resolve by block number first.
 		number = inputNum.Int64()
-		block, err = b.stargazerBlockByNumber(inputNum)
+		block, err = b.polarisBlockByNumber(inputNum)
 		if err != nil {
 			b.logger.Error("eth.rpc.backend.StateAndHeaderByNumberOrHash", "number", inputNum,
 				"err", err)
 			return nil, nil, err
 		}
 	} else if hash, ok = blockNrOrHash.Hash(); ok {
 		// Try to resolve by hash next.
-		block, err = b.stargazerBlockByHash(hash)
+		block, err = b.polarisBlockByHash(hash)
 		if err != nil {
 			b.logger.Error("eth.rpc.backend.StateAndHeaderByNumberOrHash", "hash", hash,
 				"err", err)
@@ -458,7 +458,7 @@ func (b *backend) GetBody(_ context.Context, hash common.Hash,
 		b.logger.Error("eth.rpc.backend.GetBody", "number", number, "hash", hash)
 		return nil, errors.New("invalid arguments; expect hash and no special block numbers")
 	}
-	block, err := b.stargazerBlockByNumberOrHash(BlockNumberOrHash{BlockNumber: &number, BlockHash: &hash})
+	block, err := b.polarisBlockByNumberOrHash(BlockNumberOrHash{BlockNumber: &number, BlockHash: &hash})
 	if err != nil {
 		b.logger.Error("eth.rpc.backend.GetBody", "number", number, "hash", hash)
 		return nil, err
@@ -527,16 +527,16 @@ func (b *backend) PeerCount() hexutil.Uint {
 // Polaris Helpers
 // ==============================================================================
 
-// `stargazerBlockByNumberOrHash` returns the block identified by `number` or `hash`.
-func (b *backend) stargazerBlockByNumberOrHash(
+// `polarisBlockByNumberOrHash` returns the block identified by `number` or `hash`.
+func (b *backend) polarisBlockByNumberOrHash(
 	blockNrOrHash BlockNumberOrHash,
 ) (*types.Block, error) {
 	// First we try to get by hash.
 	if hash, ok := blockNrOrHash.Hash(); ok {
 		block, err := b.chain.GetPolarisBlockByHash(hash)
 		if err != nil {
 			return nil, errorslib.Wrapf(ErrBlockNotFound,
-				"stargazerBlockByNumberOrHash: hash [%s]", hash.String())
+				"polarisBlockByNumberOrHash: hash [%s]", hash.String())
 		}
 
 		// If the has is found, we have the canonical chain.
@@ -545,30 +545,30 @@ func (b *backend) stargazerBlockByNumberOrHash(
 		}
 		if blockNrOrHash.RequireCanonical {
 			return nil, errorslib.Wrapf(ErrHashNotCanonical,
-				"stargazerBlockByNumberOrHash: hash [%s]", hash.String())
+				"polarisBlockByNumberOrHash: hash [%s]", hash.String())
 		}
 		// If not we try to query by number as a backup.
 	}
 
 	// Then we try to get the block by number
 	if blockNr, ok := blockNrOrHash.Number(); ok {
-		block, err := b.stargazerBlockByNumber(blockNr)
+		block, err := b.polarisBlockByNumber(blockNr)
 		if err != nil {
 			return nil, errorslib.Wrapf(ErrBlockNotFound,
-				"stargazerBlockByNumberOrHash: number [%d]", blockNr)
+				"polarisBlockByNumberOrHash: number [%d]", blockNr)
 		}
 		return block, nil
 	}
 	return nil, errors.New("invalid arguments; neither block nor hash specified")
 }
 
-// `stargazerBlockByHash` returns the stargazer block identified by `hash`.
-func (b *backend) stargazerBlockByHash(hash common.Hash) (*types.Block, error) {
+// `polarisBlockByHash` returns the polaris block identified by `hash`.
+func (b *backend) polarisBlockByHash(hash common.Hash) (*types.Block, error) {
 	return b.chain.GetPolarisBlockByHash(hash)
 }
 
-// `stargazerBlockByNumber` returns the stargazer block identified by `number.
-func (b *backend) stargazerBlockByNumber(number BlockNumber) (*types.Block, error) {
+// `polarisBlockByNumber` returns the polaris block identified by `number.
+func (b *backend) polarisBlockByNumber(number BlockNumber) (*types.Block, error) {
 	switch number { //nolint:nolintlint,exhaustive // golangci-lint bug?
 	case SafeBlockNumber, FinalizedBlockNumber:
 		return b.chain.FinalizedBlock()

lib/README.md

@@ -1,3 +1,3 @@
-# stargazer-lib
+# polaris-lib
 
 ## TODO: move this folder to another repo later on.

runtime/Dockerfile

@@ -23,12 +23,12 @@ ARG GO_VERSION
 # Use the latest foundry image
 FROM ghcr.io/foundry-rs/foundry as foundry
 
-WORKDIR /stargazer
+WORKDIR /polaris
 
 # Build and test the source code
 ARG PRECOMPILE_CONTRACTS_DIR
 COPY ${PRECOMPILE_CONTRACTS_DIR} ${PRECOMPILE_CONTRACTS_DIR}
-WORKDIR /stargazer/${PRECOMPILE_CONTRACTS_DIR}
+WORKDIR /polaris/${PRECOMPILE_CONTRACTS_DIR}
 
 RUN forge build
 
@@ -40,7 +40,7 @@ RUN forge build
 FROM golang:${GO_VERSION}-alpine as builder
 
 # Copy our source code into the container
-WORKDIR /stargazer
+WORKDIR /polaris
 COPY . .
 
 # Setup some alpine stuff that nobody really knows why we need other
@@ -56,7 +56,7 @@ RUN apk add linux-headers
 
 # Copy the forge output
 ARG PRECOMPILE_CONTRACTS_DIR
-# COPY --from=foundry /stargazer/${PRECOMPILE_CONTRACTS_DIR}/out /stargazer//${PRECOMPILE_CONTRACTS_DIR}/out
+# COPY --from=foundry /polaris/${PRECOMPILE_CONTRACTS_DIR}/out /polaris//${PRECOMPILE_CONTRACTS_DIR}/out
 
 # Copy the go mod and sum files
 COPY go.mod ./
@@ -81,7 +81,7 @@ RUN --mount=type=cache,target=/root/.cache/go-build \
     -X github.com/cosmos/cosmos-sdk/types.DBBackend="pebbledb" \
     -w -s -linkmode=external -extldflags '-Wl,-z,muldefs -static'" \
     -trimpath \
-    -o /stargazer/bin/ \
+    -o /polaris/bin/ \
     ./...
 
 #######################################################
@@ -93,12 +93,12 @@ FROM golang:${GO_VERSION}-alpine
 RUN apk add --no-cache bash
 RUN apk add --no-cache jq
 
-WORKDIR /stargazer
+WORKDIR /polaris
 
-COPY --from=builder /stargazer/bin/stargazerd /bin/
-COPY --from=builder /stargazer/init.sh /stargazer/
+COPY --from=builder /polaris/bin/polard /bin/
+COPY --from=builder /polaris/init.sh /polaris/
 
-ENV HOME /stargazer
+ENV HOME /polaris
 WORKDIR $HOME
 
 # TODO: reduce ports and clarify 

runtime/app.go

@@ -177,7 +177,7 @@ type PolarisApp struct {
 	GroupKeeper           groupkeeper.Keeper
 	ConsensusParamsKeeper consensuskeeper.Keeper
 
-	// stargazer keepers
+	// polaris keepers
 	EVMKeeper *evmkeeper.Keeper
 
 	// simulation manager
@@ -191,7 +191,7 @@ func init() {
 		panic(err)
 	}
 
-	DefaultNodeHome = filepath.Join(userHomeDir, ".stargazerapp")
+	DefaultNodeHome = filepath.Join(userHomeDir, ".polard")
 }
 
 // NewPolarisApp returns a reference to an initialized PolarisApp.
@@ -454,7 +454,7 @@ func (app *PolarisApp) RegisterAPIRoutes(apiSvr *api.Server, apiConfig config.AP
 	if err := server.RegisterSwaggerAPI(apiSvr.ClientCtx, apiSvr.Router, apiConfig.Swagger); err != nil {
 		panic(err)
 	}
-	// Register Ethereum JSON-RPC API as needed by stargazer.
+	// Register Ethereum JSON-RPC API as needed by polaris.
 	evmrpc.RegisterJSONRPCServer(apiSvr.ClientCtx, apiSvr.Router, app.EVMKeeper.GetRPCProvider())
 }
 

runtime/cmd/stargazerd/cmd/root.go renamed to runtime/cmd/polard/cmd/root.go

@@ -75,7 +75,7 @@ import (
 // 	WithKeyringOptions(hd.EthSecp256k1Option()).
 // 	WithViper(EnvPrefix)
 
-// NewRootCmd creates a new root command for stargazerd. It is called once in the
+// NewRootCmd creates a new root command for polard. It is called once in the
 // main function.
 func NewRootCmd() *cobra.Command {
 	// we "pre"-instantiate the application for getting the injected/configured encoding configuration
@@ -100,7 +100,7 @@ func NewRootCmd() *cobra.Command {
 		WithViper("") // In simapp, we don't use any prefix for env variables.
 
 	rootCmd := &cobra.Command{
-		Use:   "stargazerd",
+		Use:   "polard",
 		Short: "simulation app",
 		PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
 			// set the default command outputs
@@ -215,7 +215,7 @@ func addModuleInitFlags(startCmd *cobra.Command) {
 	crisis.AddModuleInitFlags(startCmd)
 }
 
-// genesisCommand builds genesis-related `stargazerd genesis` command. Users may provide application specific commands as a parameter.
+// genesisCommand builds genesis-related `polard genesis` command. Users may provide application specific commands as a parameter.
 func genesisCommand(encodingConfig params.EncodingConfig, cmds ...*cobra.Command) *cobra.Command {
 	cmd := genutilcli.GenesisCoreCommand(encodingConfig.TxConfig, runtime.ModuleBasics, runtime.DefaultNodeHome)
 
@@ -301,7 +301,7 @@ func appExport(
 	appOpts servertypes.AppOptions,
 	modulesToExport []string,
 ) (servertypes.ExportedApp, error) {
-	var stargazerApp *runtime.PolarisApp
+	var polarisApp *runtime.PolarisApp
 
 	// this check is necessary as we use the flag in x/upgrade.
 	// we can exit more gracefully by checking the flag here.
@@ -320,20 +320,20 @@ func appExport(
 	appOpts = viperAppOpts
 
 	if height != -1 {
-		stargazerApp = runtime.NewPolarisApp(logger, db, traceStore, false, appOpts)
+		polarisApp = runtime.NewPolarisApp(logger, db, traceStore, false, appOpts)
 
-		if err := stargazerApp.LoadHeight(height); err != nil {
+		if err := polarisApp.LoadHeight(height); err != nil {
 			return servertypes.ExportedApp{}, err
 		}
 	} else {
-		stargazerApp = runtime.NewPolarisApp(logger, db, traceStore, true, appOpts)
+		polarisApp = runtime.NewPolarisApp(logger, db, traceStore, true, appOpts)
 	}
 
-	return stargazerApp.ExportAppStateAndValidators(forZeroHeight, jailAllowedAddrs, modulesToExport)
+	return polarisApp.ExportAppStateAndValidators(forZeroHeight, jailAllowedAddrs, modulesToExport)
 }
 
 var tempDir = func() string {
-	dir, err := os.MkdirTemp("", "stargazerapp")
+	dir, err := os.MkdirTemp("", "polarisApp")
 	if err != nil {
 		dir = runtime.DefaultNodeHome
 	}