Merge pull request #36 from kjessec/feat/launch

feat: use opinit/launch

Author: beer-1

app/app.go

@@ -6,6 +6,7 @@ import (
 	"net/http"
 	"os"
 	"path/filepath"
+	"strings"
 
 	"github.com/gorilla/mux"
 	"github.com/rakyll/statik/fs"
@@ -972,9 +973,22 @@ func NewMinitiaApp(
 	}
 	err = msgservice.ValidateProtoAnnotations(protoFiles)
 	if err != nil {
-		// Once we switch to using protoreflect-based antehandlers, we might
-		// want to panic here instead of logging a warning.
-		fmt.Fprintln(os.Stderr, err.Error())
+		errMsg := ""
+
+		// ignore injective proto annotations comes from github.com/cosoms/relayer
+		for _, s := range strings.Split(err.Error(), "\n") {
+			if strings.Contains(s, "injective") {
+				continue
+			}
+
+			errMsg += s + "\n"
+		}
+
+		if errMsg != "" {
+			// Once we switch to using protoreflect-based antehandlers, we might
+			// want to panic here instead of logging a warning.
+			fmt.Fprintln(os.Stderr, errMsg)
+		}
 	}
 
 	// must be before Loading version

cmd/minitiad/launch.go

@@ -0,0 +1,126 @@
+package main
+
+import (
+	"encoding/json"
+	"os"
+
+	wasmkeeper "github.com/CosmWasm/wasmd/x/wasm/keeper"
+	wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/module"
+	"github.com/initia-labs/OPinit/contrib/launchtools"
+	"github.com/initia-labs/OPinit/contrib/launchtools/steps"
+	"github.com/initia-labs/initia/app/params"
+	minitiaapp "github.com/initia-labs/miniwasm/app"
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+)
+
+// DefaultLaunchStepFactories is a list of default launch step factories.
+var DefaultLaunchStepFactories = []launchtools.LauncherStepFuncFactory[launchtools.Input]{
+	steps.InitializeConfig,
+	steps.InitializeRPCHelpers,
+
+	// Initialize genesis
+	steps.InitializeGenesis,
+
+	// Add system keys to the keyring
+	steps.InitializeKeyring,
+
+	// Run the app
+	steps.RunApp,
+
+	// MINIWASM: Store/Instantiate cw721 and ics721 contracts
+	StoreAndInstantiateNFTContracts,
+
+	// Establish IBC channels for fungible and NFT transfer
+	// MINIWASM: Use wasm contract addresses for srcPort, dstPort, channelVersion
+	steps.EstablishIBCChannelsWithNFTTransfer(func() (string, string, string) {
+		return "wasm." + wasmkeeper.BuildContractAddressClassic(2, 1).String(),
+			"nft-transfer",
+			"ics721-1"
+	}),
+
+	// Enable the oracle
+	steps.EnableOracle,
+
+	// Create OP Bridge, using open channel states
+	steps.InitializeOpBridge,
+
+	// Cleanup
+	steps.StopApp,
+}
+
+func LaunchCommand(ac *appCreator, enc params.EncodingConfig, mbm module.BasicManager) *cobra.Command {
+	return launchtools.LaunchCmd(
+		ac,
+		func(denom string) map[string]json.RawMessage {
+			return minitiaapp.NewDefaultGenesisState(enc.Codec, mbm, denom)
+		},
+		DefaultLaunchStepFactories,
+	)
+}
+
+// StoreAndInstantiateNFTContracts stores and instantiates cw721 and ics721 contracts
+func StoreAndInstantiateNFTContracts(input launchtools.Input) launchtools.LauncherStepFunc {
+	return func(ctx launchtools.Launcher) error {
+		ctx.Logger().Info("Storing and instantiating cw721 and ics721 contracts")
+
+		cw721, err := os.ReadFile("contrib/wasm/cw721_base.wasm")
+		if err != nil {
+			return errors.Wrapf(err, "failed to read cw721_base.wasm")
+		}
+
+		ics721, err := os.ReadFile("contrib/wasm/ics721_base.wasm")
+		if err != nil {
+			return errors.Wrapf(err, "failed to read ics721_base.wasm")
+		}
+
+		msgs := []sdk.Msg{
+			&wasmtypes.MsgStoreCode{
+				Sender:                input.SystemKeys.Validator.Address,
+				WASMByteCode:          cw721,
+				InstantiatePermission: nil,
+			},
+			&wasmtypes.MsgStoreCode{
+				Sender:                input.SystemKeys.Validator.Address,
+				WASMByteCode:          ics721,
+				InstantiatePermission: nil,
+			},
+			&wasmtypes.MsgInstantiateContract{
+				Sender: input.SystemKeys.Validator.Address,
+				Admin:  input.SystemKeys.Validator.Address,
+				CodeID: 2,
+				Label:  "ics721",
+				Msg:    []byte(`{"cw721_base_code_id":1}`),
+				Funds:  nil,
+			},
+		}
+
+		for i, msg := range msgs {
+			ctx.Logger().Info(
+				"Broadcasting tx to store and instantiate cw721 and ics721 contracts",
+				"step", i+1,
+			)
+
+			res, err := ctx.GetRPCHelperL2().BroadcastTxAndWait(
+				input.SystemKeys.Validator.Address,
+				input.SystemKeys.Validator.Mnemonic,
+				10000000,
+				sdk.NewCoins(sdk.NewInt64Coin(input.L2Config.Denom, 1500000)),
+				msg,
+			)
+
+			if err != nil {
+				return errors.Wrapf(err, "failed to store and instantiate nft contracts")
+			}
+
+			ctx.Logger().Info(
+				"Successfully stored and instantiated cw721 and ics721 contracts",
+				"tx_hash", res.Hash,
+			)
+		}
+
+		return nil
+	}
+}

cmd/minitiad/root.go

@@ -1,12 +1,14 @@
 package main
 
 import (
+	"context"
 	"errors"
 	"io"
 	"os"
 	"path"
 
 	tmcli "github.com/cometbft/cometbft/libs/cli"
+	"golang.org/x/sync/errgroup"
 
 	"github.com/prometheus/client_golang/prometheus"
 
@@ -63,7 +65,9 @@ func NewRootCmd() (*cobra.Command, params.EncodingConfig) {
 	sdkConfig.SetBech32PrefixForValidator(validatorAddressPrefix, validatorPubKeyPrefix)
 	sdkConfig.SetBech32PrefixForConsensusNode(consNodeAddressPrefix, consNodePubKeyPrefix)
 	sdkConfig.SetAddressVerifier(wasmtypes.VerifyAddressLen())
-	sdkConfig.Seal()
+
+	// seal moved to post setup
+	// sdkConfig.Seal()
 
 	encodingConfig := minitiaapp.MakeEncodingConfig()
 	basicManager := minitiaapp.BasicManager()
@@ -145,18 +149,23 @@ func NewRootCmd() (*cobra.Command, params.EncodingConfig) {
 }
 
 func initRootCmd(rootCmd *cobra.Command, encodingConfig params.EncodingConfig, basicManager module.BasicManager) {
-	a := &appCreator{nil, encodingConfig}
-	// you can get app from a.app in post setup handler
+	a := &appCreator{}
 
 	rootCmd.AddCommand(
 		InitCmd(basicManager, minitiaapp.DefaultNodeHome),
 		debug.Cmd(),
 		confixcmd.ConfigCommand(),
-		pruning.Cmd(a.newApp, minitiaapp.DefaultNodeHome),
-		snapshot.Cmd(a.newApp),
+		pruning.Cmd(a.AppCreator(), minitiaapp.DefaultNodeHome),
+		snapshot.Cmd(a.AppCreator()),
 	)
 
-	server.AddCommands(rootCmd, minitiaapp.DefaultNodeHome, a.newApp, a.appExport, addModuleInitFlags)
+	server.AddCommandsWithStartCmdOptions(rootCmd, minitiaapp.DefaultNodeHome, a.AppCreator(), a.appExport, server.StartCmdOptions{
+		AddFlags: addModuleInitFlags,
+		PostSetup: func(svrCtx *server.Context, clientCtx client.Context, ctx context.Context, g *errgroup.Group) error {
+			sdk.GetConfig().Seal()
+			return nil
+		},
+	})
 	wasmcli.ExtendUnsafeResetAllCmd(rootCmd)
 
 	// add keybase, auxiliary RPC, query, and tx child commands
@@ -167,6 +176,9 @@ func initRootCmd(rootCmd *cobra.Command, encodingConfig params.EncodingConfig, b
 		txCommand(),
 		keys.Commands(),
 	)
+
+	// add launch commands
+	rootCmd.AddCommand(LaunchCommand(a, encodingConfig, basicManager))
 }
 
 func addModuleInitFlags(startCmd *cobra.Command) {
@@ -242,30 +254,34 @@ func txCommand() *cobra.Command {
 }
 
 type appCreator struct {
-	app            servertypes.Application
-	encodingConfig params.EncodingConfig
+	app servertypes.Application
 }
 
 // newApp is an AppCreator
-func (a appCreator) newApp(logger log.Logger, db dbm.DB, traceStore io.Writer, appOpts servertypes.AppOptions) servertypes.Application {
-	baseappOptions := server.DefaultBaseappOptions(appOpts)
+func (a *appCreator) AppCreator() servertypes.AppCreator {
+	return func(logger log.Logger, db dbm.DB, traceStore io.Writer, appOpts servertypes.AppOptions) servertypes.Application {
+		baseappOptions := server.DefaultBaseappOptions(appOpts)
 
-	var wasmOpts []wasmkeeper.Option
-	if cast.ToBool(appOpts.Get("telemetry.enabled")) {
-		wasmOpts = append(wasmOpts, wasmkeeper.WithVMCacheMetrics(prometheus.DefaultRegisterer))
-	}
+		var wasmOpts []wasmkeeper.Option
+		if cast.ToBool(appOpts.Get("telemetry.enabled")) {
+			wasmOpts = append(wasmOpts, wasmkeeper.WithVMCacheMetrics(prometheus.DefaultRegisterer))
+		}
 
-	app := minitiaapp.NewMinitiaApp(
-		logger, db, traceStore, true,
-		wasmOpts,
-		appOpts,
-		baseappOptions...,
-	)
+		app := minitiaapp.NewMinitiaApp(
+			logger, db, traceStore, true,
+			wasmOpts,
+			appOpts,
+			baseappOptions...,
+		)
+
+		a.app = app
 
-	// store app in creator
-	a.app = app
+		return app
+	}
+}
 
-	return app
+func (a *appCreator) App() servertypes.Application {
+	return a.app
 }
 
 func (a appCreator) appExport(