feat: add upgrade oracle tx & cli

proto/panacea/oracle/v2/genesis.proto

@@ -11,7 +11,9 @@ import "panacea/oracle/v2/oracle.proto";
 message GenesisState {
   repeated Oracle oracles = 1 [(gogoproto.nullable) = false];
   repeated OracleRegistration oracle_registrations = 2 [(gogoproto.nullable) = false];
-  Params params = 3 [(gogoproto.nullable) = false];
+  repeated OracleUpgrade oracle_upgrades = 3 [(gogoproto.nullable) = false];
+  OracleUpgradeInfo oracle_upgrade_info = 4;
+  Params params = 5 [(gogoproto.nullable) = false];
 }
 
 // Params defines the oracle module's params.

x/oracle/abci_test.go

@@ -55,6 +55,7 @@ func (suite *abciTestSuite) TestOracleUpgradeSuccess() {
 	oracle.EndBlocker(ctx, suite.OracleKeeper)
 
 	suite.Require().Equal(upgradeUniqueID, suite.OracleKeeper.GetParams(ctx).UniqueId)
+
 }
 
 func (suite *abciTestSuite) TestOracleUpgradeFailedBeforeReachUpgradeHeight() {

x/oracle/client/cli/tx.go

@@ -32,6 +32,7 @@ func GetTxCmd() *cobra.Command {
 
 	cmd.AddCommand(CmdRegisterOracle())
 	cmd.AddCommand(CmdUpdateOracleInfo())
+	cmd.AddCommand(CmdUpgradeOracle())
 
 	return cmd
 }

x/oracle/client/cli/txUpgradeOracle.go

@@ -0,0 +1,107 @@
+package cli
+
+import (
+	"encoding/base64"
+	"encoding/hex"
+	"fmt"
+	"strconv"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/client/tx"
+	"github.com/medibloc/panacea-core/v2/x/oracle/types"
+	"github.com/spf13/cobra"
+)
+
+func CmdUpgradeOracle() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "upgrade-oracle",
+		Short: "Upgrade an oracle",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientTxContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			oracleAddress := clientCtx.GetFromAddress().String()
+
+			uniqueID, err := cmd.Flags().GetString(flagOracleUniqueID)
+			if err != nil {
+				return fmt.Errorf("failed to get oracle unique ID")
+			}
+
+			nodePubkeyStr, err := cmd.Flags().GetString(flagNodePublicKey)
+			if err != nil {
+				return fmt.Errorf("failed to get node public key")
+			}
+
+			nodePubKey, err := base64.StdEncoding.DecodeString(nodePubkeyStr)
+			if err != nil {
+				return err
+			}
+
+			nodePubkeyRemoteReportStr, err := cmd.Flags().GetString(flagNodePubKeyRemoteReport)
+			if err != nil {
+				return fmt.Errorf("failed to get node public key remote report")
+			}
+
+			nodePubKeyRemoteReport, err := base64.StdEncoding.DecodeString(nodePubkeyRemoteReportStr)
+			if err != nil {
+				return err
+			}
+
+			trustedBlockHeightStr, err := cmd.Flags().GetString(flagTrustedBlockHeight)
+			if err != nil {
+				return fmt.Errorf("failed to get trsuted block height")
+			}
+
+			trustedBlockHeight, err := strconv.ParseInt(trustedBlockHeightStr, 10, 64)
+			if err != nil {
+				return err
+			}
+
+			trustedBlockHashStr, err := cmd.Flags().GetString(flagTrustedBlockHash)
+			if err != nil {
+				return fmt.Errorf("failed to get trsuted block hash")
+			}
+
+			trustedBlockHash, err := hex.DecodeString(trustedBlockHashStr)
+			if err != nil {
+				return err
+			}
+
+			msg := types.NewMsgUpgradeOracle(uniqueID, oracleAddress, nodePubKey, nodePubKeyRemoteReport, trustedBlockHeight, trustedBlockHash)
+			if err := msg.ValidateBasic(); err != nil {
+				return err
+			}
+
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
+		},
+	}
+
+	cmd.Flags().String(flagOracleUniqueID, "", "unique ID for oracle")
+	cmd.Flags().String(flagNodePublicKey, "", "node public key for oracle")
+	cmd.Flags().String(flagNodePubKeyRemoteReport, "", "node public key remote report for oracle")
+	cmd.Flags().String(flagTrustedBlockHeight, "", "trusted block height of panacea trusted block")
+	cmd.Flags().String(flagTrustedBlockHash, "", "trusted block hash of panacea trusted block")
+
+	if err := cmd.MarkFlagRequired(flagOracleUniqueID); err != nil {
+		panic(err)
+	}
+	if err := cmd.MarkFlagRequired(flagNodePublicKey); err != nil {
+		panic(err)
+	}
+	if err := cmd.MarkFlagRequired(flagNodePubKeyRemoteReport); err != nil {
+		panic(err)
+	}
+	if err := cmd.MarkFlagRequired(flagTrustedBlockHeight); err != nil {
+		panic(err)
+	}
+	if err := cmd.MarkFlagRequired(flagTrustedBlockHash); err != nil {
+		panic(err)
+	}
+
+	flags.AddTxFlagsToCmd(cmd)
+
+	return cmd
+}

x/oracle/genesis.go

@@ -21,6 +21,18 @@ func InitGenesis(ctx sdk.Context, k keeper.Keeper, genState types.GenesisState)
 		}
 	}
 
+	for _, oracleUpgrade := range genState.OracleUpgrades {
+		if err := k.SetOracleUpgrade(ctx, &oracleUpgrade); err != nil {
+			panic(err)
+		}
+	}
+
+	if genState.OracleUpgradeInfo != nil {
+		if err := k.SetOracleUpgradeInfo(ctx, genState.OracleUpgradeInfo); err != nil {
+			panic(err)
+		}
+	}
+
 	k.SetParams(ctx, genState.Params)
 }
 
@@ -40,6 +52,18 @@ func ExportGenesis(ctx sdk.Context, k keeper.Keeper) *types.GenesisState {
 	}
 	genesis.OracleRegistrations = oracleRegistrations
 
+	oracleUpgrades, err := k.GetAllOracleUpgradeList(ctx)
+	if err != nil {
+		panic(err)
+	}
+	genesis.OracleUpgrades = oracleUpgrades
+
+	upgradeInfo, err := k.GetOracleUpgradeInfo(ctx)
+	if err != nil {
+		panic(err)
+	}
+	genesis.OracleUpgradeInfo = upgradeInfo
+
 	genesis.Params = k.GetParams(ctx)
 
 	return genesis

x/oracle/genesis_test.go

@@ -17,8 +17,9 @@ import (
 type genesisTestSuite struct {
 	testsuite.TestSuite
 
-	uniqueID string
-	endpoint string
+	uniqueID  string
+	uniqueID2 string
+	endpoint  string
 
 	oracleAccPrivKey cryptotypes.PrivKey
 	oracleAccPubKey  cryptotypes.PubKey
@@ -38,6 +39,7 @@ func TestGenesisTestSuite(t *testing.T) {
 
 func (suite *genesisTestSuite) BeforeTest(_, _ string) {
 	suite.uniqueID = "uniqueID"
+	suite.uniqueID2 = "uniqueID2"
 	suite.endpoint = "https://my-validator.org"
 
 	suite.oracleAccPrivKey = secp256k1.GenPrivKey()
@@ -86,6 +88,7 @@ func (suite *genesisTestSuite) TestInitGenesis() {
 				OracleCommissionRate:          sdk.NewDecWithPrec(1, 1),
 				OracleCommissionMaxRate:       sdk.NewDecWithPrec(2, 1),
 				OracleCommissionMaxChangeRate: sdk.NewDecWithPrec(1, 2),
+				EncryptedOraclePrivKey:        nil,
 			},
 			{
 				UniqueId:                      suite.uniqueID,
@@ -98,8 +101,33 @@ func (suite *genesisTestSuite) TestInitGenesis() {
 				OracleCommissionRate:          sdk.NewDecWithPrec(1, 1),
 				OracleCommissionMaxRate:       sdk.NewDecWithPrec(2, 1),
 				OracleCommissionMaxChangeRate: sdk.NewDecWithPrec(1, 2),
+				EncryptedOraclePrivKey:        nil,
 			},
 		},
+		OracleUpgrades: []types.OracleUpgrade{
+			{
+				UniqueId:               suite.uniqueID2,
+				OracleAddress:          suite.oracleAccAddr.String(),
+				NodePubKey:             suite.nodePubKey.SerializeCompressed(),
+				NodePubKeyRemoteReport: []byte("nodePubKeyRemoteReport"),
+				TrustedBlockHeight:     10,
+				TrustedBlockHash:       nil,
+				EncryptedOraclePrivKey: nil,
+			},
+			{
+				UniqueId:               suite.uniqueID2,
+				OracleAddress:          suite.oracle2AccAddr.String(),
+				NodePubKey:             suite.nodePubKey.SerializeCompressed(),
+				NodePubKeyRemoteReport: []byte("nodePubKeyRemoteReport"),
+				TrustedBlockHeight:     10,
+				TrustedBlockHash:       nil,
+				EncryptedOraclePrivKey: nil,
+			},
+		},
+		OracleUpgradeInfo: &types.OracleUpgradeInfo{
+			UniqueId: suite.uniqueID2,
+			Height:   100,
+		},
 		Params: types.DefaultParams(),
 	}
 
@@ -118,6 +146,18 @@ func (suite *genesisTestSuite) TestInitGenesis() {
 	getOracleRegistration, err = suite.OracleKeeper.GetOracleRegistration(suite.Ctx, suite.uniqueID, suite.oracle2AccAddr.String())
 	suite.Require().NoError(err)
 	suite.Require().Equal(genesis.OracleRegistrations[1], *getOracleRegistration)
+
+	getOracleUpgrade, err := suite.OracleKeeper.GetOracleUpgrade(suite.Ctx, suite.uniqueID2, suite.oracleAccAddr.String())
+	suite.Require().NoError(err)
+	suite.Require().Equal(genesis.OracleUpgrades[0], *getOracleUpgrade)
+	getOracleUpgrade, err = suite.OracleKeeper.GetOracleUpgrade(suite.Ctx, suite.uniqueID2, suite.oracle2AccAddr.String())
+	suite.Require().NoError(err)
+	suite.Require().Equal(genesis.OracleUpgrades[1], *getOracleUpgrade)
+
+	getOracleUpgradeInfo, err := suite.OracleKeeper.GetOracleUpgradeInfo(suite.Ctx)
+	suite.Require().NoError(err)
+	suite.Require().Equal(genesis.OracleUpgradeInfo, getOracleUpgradeInfo)
+
 }
 
 func (suite *genesisTestSuite) TestExportGenesis() {
@@ -144,15 +184,40 @@ func (suite *genesisTestSuite) TestExportGenesis() {
 		OracleCommissionRate:          sdk.NewDecWithPrec(1, 1),
 		OracleCommissionMaxRate:       sdk.NewDecWithPrec(2, 1),
 		OracleCommissionMaxChangeRate: sdk.NewDecWithPrec(1, 2),
+		EncryptedOraclePrivKey:        nil,
 	}
+
 	err = suite.OracleKeeper.SetOracleRegistration(suite.Ctx, oraRegistration)
 	suite.Require().NoError(err)
 
+	oracleUpgrade := &types.OracleUpgrade{
+		UniqueId:               suite.uniqueID2,
+		OracleAddress:          suite.oracleAccAddr.String(),
+		NodePubKey:             suite.nodePubKey.SerializeCompressed(),
+		NodePubKeyRemoteReport: []byte("nodePubKeyRemoteReport"),
+		TrustedBlockHeight:     10,
+		TrustedBlockHash:       nil,
+		EncryptedOraclePrivKey: nil,
+	}
+
+	err = suite.OracleKeeper.SetOracleUpgrade(suite.Ctx, oracleUpgrade)
+	suite.Require().NoError(err)
+
+	oracleUpgradeInfo := &types.OracleUpgradeInfo{
+		UniqueId: suite.uniqueID2,
+		Height:   100,
+	}
+
+	err = suite.OracleKeeper.SetOracleUpgradeInfo(suite.Ctx, oracleUpgradeInfo)
+	suite.Require().NoError(err)
+
 	params := types.DefaultParams()
 	suite.OracleKeeper.SetParams(suite.Ctx, params)
 
 	genesisStatus := oracle.ExportGenesis(suite.Ctx, suite.OracleKeeper)
 	suite.Require().Equal(*ora, genesisStatus.Oracles[0])
 	suite.Require().Equal(*oraRegistration, genesisStatus.OracleRegistrations[0])
+	suite.Require().Equal(*oracleUpgrade, genesisStatus.OracleUpgrades[0])
+	suite.Require().Equal(oracleUpgradeInfo, genesisStatus.OracleUpgradeInfo)
 	suite.Require().Equal(params, genesisStatus.Params)
 }

x/oracle/handler.go

@@ -26,6 +26,9 @@ func NewHandler(k keeper.Keeper) sdk.Handler {
 		case *types.MsgUpdateOracleInfo:
 			res, err := msgServer.UpdateOracleInfo(sdk.WrapSDKContext(ctx), msg)
 			return sdk.WrapServiceResult(ctx, res, err)
+		case *types.MsgUpgradeOracle:
+			res, err := msgServer.UpgradeOracle(sdk.WrapSDKContext(ctx), msg)
+			return sdk.WrapServiceResult(ctx, res, err)
 		default:
 			errMsg := fmt.Sprintf("unrecognized %s message type: %T", types.ModuleName, msg)
 			return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, errMsg)

x/oracle/keeper/grpc_query_oracle.go

@@ -94,6 +94,11 @@ func (k Keeper) OracleRegistration(goCtx context.Context, request *types.QueryOr
 	return &types.QueryOracleRegistrationResponse{OracleRegistration: oracleRegistration}, nil
 }
 
+func (k Keeper) Params(goCtx context.Context, _ *types.QueryOracleParamsRequest) (*types.QueryParamsResponse, error) {
+	params := k.GetParams(sdk.UnwrapSDKContext(goCtx))
+	return &types.QueryParamsResponse{Params: &params}, nil
+}
+
 func (k Keeper) OracleUpgradeInfo(ctx context.Context, _ *types.QueryOracleUpgradeInfoRequest) (*types.QueryOracleUpgradeInfoResponse, error) {
 	upgradeInfo, err := k.GetOracleUpgradeInfo(sdk.UnwrapSDKContext(ctx))
 	if err != nil {
@@ -107,12 +112,12 @@ func (k Keeper) OracleUpgradeInfo(ctx context.Context, _ *types.QueryOracleUpgra
 	}, nil
 }
 
-func (k Keeper) Params(goCtx context.Context, _ *types.QueryOracleParamsRequest) (*types.QueryParamsResponse, error) {
-	params := k.GetParams(sdk.UnwrapSDKContext(goCtx))
-	return &types.QueryParamsResponse{Params: &params}, nil
-}
-
 func (k Keeper) OracleUpgrade(goCtx context.Context, request *types.QueryOracleUpgradeRequest) (*types.QueryOracleUpgradeResponse, error) {
-	// TODO: Implementation
-	return &types.QueryOracleUpgradeResponse{}, nil
-}
+
+	oracleUpgrade, err := k.GetOracleUpgrade(sdk.UnwrapSDKContext(goCtx), request.UniqueId, request.OracleAddress)
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.QueryOracleUpgradeResponse{OracleUpgrade: oracleUpgrade}, nil
+}

x/oracle/keeper/grpc_query_oracle_test.go

@@ -279,3 +279,29 @@ func (suite *queryOracleTestSuite) TestOracleUpgradeInfo() {
 	suite.Require().Equal(upgradeInfo.UniqueId, getUpgradeInfo.OracleUpgradeInfo.UniqueId)
 	suite.Require().Equal(upgradeInfo.Height, getUpgradeInfo.OracleUpgradeInfo.Height)
 }
+
+func (suite *queryOracleTestSuite) TestOracleUpgrade() {
+	ctx := suite.Ctx
+	oracleKeeper := suite.OracleKeeper
+
+	oracleUpgrade := &types.OracleUpgrade{
+		UniqueId:               suite.uniqueID,
+		OracleAddress:          suite.oracleAccAddr.String(),
+		NodePubKey:             suite.nodePubKey.SerializeCompressed(),
+		NodePubKeyRemoteReport: []byte("nodePubKeyRemoteReport"),
+		TrustedBlockHeight:     10,
+		TrustedBlockHash:       []byte("hash"),
+		EncryptedOraclePrivKey: nil,
+	}
+
+	suite.Require().NoError(oracleKeeper.SetOracleUpgrade(ctx, oracleUpgrade))
+
+	getOracleUpgrade, err := oracleKeeper.GetOracleUpgrade(ctx, suite.uniqueID, suite.oracleAccAddr.String())
+	suite.Require().NoError(err)
+	suite.Require().Equal(oracleUpgrade.UniqueId, getOracleUpgrade.UniqueId)
+	suite.Require().Equal(oracleUpgrade.OracleAddress, getOracleUpgrade.OracleAddress)
+	suite.Require().Equal(oracleUpgrade.NodePubKey, getOracleUpgrade.NodePubKey)
+	suite.Require().Equal(oracleUpgrade.NodePubKeyRemoteReport, getOracleUpgrade.NodePubKeyRemoteReport)
+	suite.Require().Equal(oracleUpgrade.TrustedBlockHeight, getOracleUpgrade.TrustedBlockHeight)
+	suite.Require().Equal(oracleUpgrade.TrustedBlockHash, getOracleUpgrade.TrustedBlockHash)
+}

x/oracle/keeper/msg_server_oracle.go

@@ -60,7 +60,9 @@ func (m msgServer) UpdateOracleInfo(goCtx context.Context, msg *types.MsgUpdateO
 }
 
 func (m msgServer) UpgradeOracle(goCtx context.Context, msg *types.MsgUpgradeOracle) (*types.MsgUpgradeOracleResponse, error) {
-	// TODO: Implementation
+	if err := m.Keeper.UpgradeOracle(sdk.UnwrapSDKContext(goCtx), msg); err != nil {
+		return nil, err
+	}
 	return &types.MsgUpgradeOracleResponse{}, nil
 }