feat: implement approve oracle upgrade tx

proto/panacea/oracle/v2/tx.proto

@@ -54,6 +54,7 @@ message MsgApproveOracleRegistration {
 
 // ApprovalSharingOracleKey defines approval for sharing oracle key encrypted with target oracle's node public key
 message ApprovalSharingOracleKey {
+  // approver's unique ID
   string unique_id = 1;
   string approver_oracle_address = 2;
   string target_oracle_address = 3;

x/oracle/keeper/msg_server_oracle.go

@@ -67,6 +67,18 @@ func (m msgServer) UpgradeOracle(goCtx context.Context, msg *types.MsgUpgradeOra
 }
 
 func (m msgServer) ApproveOracleUpgrade(goCtx context.Context, msg *types.MsgApproveOracleUpgrade) (*types.MsgApproveOracleUpgradeResponse, error) {
-	// TODO: Implementation
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	if err := m.Keeper.ApproveOracleUpgrade(ctx, msg); err != nil {
+		return nil, err
+	}
+
+	ctx.EventManager().EmitEvent(
+		sdk.NewEvent(
+			sdk.EventTypeMessage,
+			sdk.NewAttribute(sdk.AttributeKeyModule, types.ModuleName),
+		),
+	)
+
 	return &types.MsgApproveOracleUpgradeResponse{}, nil
 }

x/oracle/keeper/oracle.go

@@ -12,25 +12,21 @@ import (
 func (k Keeper) RegisterOracle(ctx sdk.Context, msg *types.MsgRegisterOracle) error {
 	oracleRegistration := types.NewOracleRegistration(msg)
 
-	if err := oracleRegistration.ValidateBasic(); err != nil {
-		return err
-	}
-
 	params := k.GetParams(ctx)
-	if params.UniqueId != oracleRegistration.UniqueId {
-		return sdkerrors.Wrapf(types.ErrOracleRegistration, "is not match the currently active uniqueID")
+	if params.UniqueId != msg.UniqueId {
+		return sdkerrors.Wrapf(types.ErrRegisterOracle, types.ErrInvalidUniqueID.Error())
 	}
 
-	if oracle, err := k.GetOracle(ctx, oracleRegistration.OracleAddress); !errors.Is(types.ErrOracleNotFound, err) {
-		if oracle != nil {
-			return sdkerrors.Wrapf(types.ErrOracleRegistration, "already registered oracle. address(%s)", oracleRegistration.OracleAddress)
-		} else {
-			return sdkerrors.Wrapf(types.ErrOracleRegistration, err.Error())
-		}
+	existing, err := k.GetOracleRegistration(ctx, msg.GetUniqueId(), msg.GetOracleAddress())
+	if err != nil && !errors.Is(err, types.ErrOracleRegistrationNotFound) {
+		return sdkerrors.Wrapf(types.ErrRegisterOracle, err.Error())
+	}
+	if existing != nil {
+		return sdkerrors.Wrapf(types.ErrRegisterOracle, fmt.Sprintf("already registered oracle. address(%s)", msg.OracleAddress))
 	}
 
 	if err := k.SetOracleRegistration(ctx, oracleRegistration); err != nil {
-		return err
+		return sdkerrors.Wrapf(types.ErrRegisterOracle, err.Error())
 	}
 
 	ctx.EventManager().EmitEvent(
@@ -40,20 +36,27 @@ func (k Keeper) RegisterOracle(ctx sdk.Context, msg *types.MsgRegisterOracle) er
 			sdk.NewAttribute(types.AttributeKeyOracleAddress, oracleRegistration.OracleAddress),
 		),
 	)
+
 	return nil
 }
 
 func (k Keeper) ApproveOracleRegistration(ctx sdk.Context, msg *types.MsgApproveOracleRegistration) error {
-
-	if err := k.validateApproveOracleRegistration(ctx, msg); err != nil {
+	// validate approval for oracle registration
+	if err := k.validateApprovalSharingOracleKey(ctx, msg.GetApprovalSharingOracleKey(), msg.GetSignature()); err != nil {
 		return sdkerrors.Wrapf(types.ErrApproveOracleRegistration, err.Error())
 	}
 
+	// get oracle registration
 	oracleRegistration, err := k.GetOracleRegistration(ctx, msg.ApprovalSharingOracleKey.UniqueId, msg.ApprovalSharingOracleKey.TargetOracleAddress)
 	if err != nil {
 		return sdkerrors.Wrapf(types.ErrApproveOracleRegistration, err.Error())
 	}
 
+	// if EncryptedOraclePrivKey is already set, return error
+	if oracleRegistration.EncryptedOraclePrivKey != nil {
+		return sdkerrors.Wrapf(types.ErrApproveOracleRegistration, "already approved oracle registration. if you want to be shared oracle private key again, please register oracle again")
+	}
+
 	oracleRegistration.EncryptedOraclePrivKey = msg.ApprovalSharingOracleKey.EncryptedOraclePrivKey
 
 	// add an encrypted oracle private key to oracleRegistration
@@ -88,33 +91,31 @@ func (k Keeper) ApproveOracleRegistration(ctx sdk.Context, msg *types.MsgApprove
 
 }
 
-// validateApproveOracleRegistration checks signature
-func (k Keeper) validateApproveOracleRegistration(ctx sdk.Context, msg *types.MsgApproveOracleRegistration) error {
-
+// validateApprovalSharingOracleKey validate unique ID of ApprovalSharingOracleKey and its signature
+func (k Keeper) validateApprovalSharingOracleKey(ctx sdk.Context, approval *types.ApprovalSharingOracleKey, signature []byte) error {
 	params := k.GetParams(ctx)
-	targetOracleAddress := msg.ApprovalSharingOracleKey.TargetOracleAddress
 
 	// check unique id
-	if msg.ApprovalSharingOracleKey.UniqueId != params.UniqueId {
+	if approval.UniqueId != params.UniqueId {
 		return types.ErrInvalidUniqueID
 	}
 
-	// verify signature
-	if err := k.VerifyOracleSignature(ctx, msg.ApprovalSharingOracleKey, msg.Signature); err != nil {
-		return err
+	// check if the approver oracle exists
+	isActive, err := k.IsActiveOracle(ctx, approval.ApproverOracleAddress)
+	if err != nil {
+		return fmt.Errorf("error occurs while checking if the oracle(%s) exists: %w", approval.ApproverOracleAddress, err)
 	}
-
-	if msg.ApprovalSharingOracleKey.EncryptedOraclePrivKey == nil {
-		return fmt.Errorf("encrypted oracle private key is nil")
+	if !isActive {
+		return fmt.Errorf("oracle(%s) is not an active oracle", approval.ApproverOracleAddress)
 	}
 
-	// check if the oracle has been already registered
-	hasOracle, err := k.HasOracle(ctx, targetOracleAddress)
-	if err != nil {
+	// verify signature
+	if err := k.VerifyOracleSignature(ctx, approval, signature); err != nil {
 		return err
 	}
-	if hasOracle {
-		return fmt.Errorf("already registered oracle. address(%s)", targetOracleAddress)
+
+	if approval.EncryptedOraclePrivKey == nil {
+		return fmt.Errorf("encrypted oracle private key is empty")
 	}
 
 	return nil
@@ -189,12 +190,12 @@ func (k Keeper) GetOracleRegistration(ctx sdk.Context, uniqueID, address string)
 	store := ctx.KVStore(k.storeKey)
 	accAddr, err := sdk.AccAddressFromBech32(address)
 	if err != nil {
-		return nil, err
+		return nil, sdkerrors.Wrapf(types.ErrGetOracleRegistration, err.Error())
 	}
 	key := types.GetOracleRegistrationKey(uniqueID, accAddr)
 	bz := store.Get(key)
 	if bz == nil {
-		return nil, sdkerrors.Wrapf(types.ErrGetOracleRegistration, "oracle registration not found")
+		return nil, types.ErrOracleRegistrationNotFound
 	}
 
 	oracleRegistration := &types.OracleRegistration{}
@@ -249,7 +250,7 @@ func (k Keeper) GetOracle(ctx sdk.Context, address string) (*types.Oracle, error
 	store := ctx.KVStore(k.storeKey)
 	accAddr, err := sdk.AccAddressFromBech32(address)
 	if err != nil {
-		return nil, err
+		return nil, sdkerrors.Wrapf(types.ErrGetOracle, err.Error())
 	}
 	key := types.GetOracleKey(accAddr)
 	bz := store.Get(key)
@@ -267,12 +268,17 @@ func (k Keeper) GetOracle(ctx sdk.Context, address string) (*types.Oracle, error
 	return oracle, nil
 }
 
-func (k Keeper) HasOracle(ctx sdk.Context, address string) (bool, error) {
-	store := ctx.KVStore(k.storeKey)
-	accAddr, err := sdk.AccAddressFromBech32(address)
+func (k Keeper) IsActiveOracle(ctx sdk.Context, oracleAddress string) (bool, error) {
+	oracle, err := k.GetOracle(ctx, oracleAddress)
 	if err != nil {
 		return false, err
 	}
 
-	return store.Has(types.GetOracleKey(accAddr)), nil
+	params := k.GetParams(ctx)
+
+	if oracle.GetUniqueId() != params.GetUniqueId() {
+		return false, types.ErrInvalidUniqueID
+	}
+
+	return true, nil
 }

x/oracle/keeper/oracle_test.go

@@ -10,7 +10,6 @@ import (
 	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
 	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	"github.com/medibloc/panacea-core/v2/types/testsuite"
 	"github.com/medibloc/panacea-core/v2/x/oracle/types"
 	"github.com/stretchr/testify/suite"
@@ -133,10 +132,11 @@ func (suite *oracleTestSuite) TestRegisterOracleSuccess() {
 	suite.Require().Equal(suite.oracleCommissionMaxChangeRate, oracleFromKeeper.OracleCommissionMaxChangeRate)
 }
 
-func (suite *oracleTestSuite) TestRegisterOracleFailedValidateToMsgOracleRegistration() {
+func (suite *oracleTestSuite) TestRegisterOracleAlreadyExistOracleRegistration() {
 	ctx := suite.Ctx
 
 	msgRegisterOracle := &types.MsgRegisterOracle{
+		UniqueId:                      suite.uniqueID,
 		OracleAddress:                 suite.oracleAccAddr.String(),
 		NodePubKey:                    suite.nodePubKey.SerializeCompressed(),
 		NodePubKeyRemoteReport:        suite.nodePubKeyRemoteReport,
@@ -148,76 +148,12 @@ func (suite *oracleTestSuite) TestRegisterOracleFailedValidateToMsgOracleRegistr
 		OracleCommissionMaxChangeRate: suite.oracleCommissionMaxChangeRate,
 	}
 
+	// first registration
 	err := suite.OracleKeeper.RegisterOracle(ctx, msgRegisterOracle)
-	suite.Require().Error(err, sdkerrors.ErrInvalidRequest)
-	suite.Require().ErrorContains(err, "uniqueID is empty")
-
-	msgRegisterOracle.UniqueId = suite.uniqueID
-	msgRegisterOracle.NodePubKey = nil
-	err = suite.OracleKeeper.RegisterOracle(ctx, msgRegisterOracle)
-	suite.Require().Error(err, sdkerrors.ErrInvalidRequest)
-	suite.Require().ErrorContains(err, "node public key is empty")
-
-	msgRegisterOracle.NodePubKey = []byte("invalidNodePubKey")
-	err = suite.OracleKeeper.RegisterOracle(ctx, msgRegisterOracle)
-	suite.Require().Error(err, sdkerrors.ErrInvalidRequest)
-	suite.Require().ErrorContains(err, "invalid node public key")
-
-	msgRegisterOracle.NodePubKey = suite.nodePubKey.SerializeCompressed()
-	msgRegisterOracle.NodePubKeyRemoteReport = nil
-	err = suite.OracleKeeper.RegisterOracle(ctx, msgRegisterOracle)
-	suite.Require().Error(err, sdkerrors.ErrInvalidRequest)
-	suite.Require().ErrorContains(err, "remote report of node public key is empty")
-
-	msgRegisterOracle.NodePubKeyRemoteReport = suite.nodePubKeyRemoteReport
-	msgRegisterOracle.TrustedBlockHeight = 0
-	err = suite.OracleKeeper.RegisterOracle(ctx, msgRegisterOracle)
-	suite.Require().Error(err, sdkerrors.ErrInvalidRequest)
-	suite.Require().ErrorContains(err, "trusted block height must be greater than zero")
-
-	msgRegisterOracle.TrustedBlockHeight = suite.trustedBlockHeight
-	msgRegisterOracle.TrustedBlockHash = nil
-	err = suite.OracleKeeper.RegisterOracle(ctx, msgRegisterOracle)
-	suite.Require().Error(err, sdkerrors.ErrInvalidRequest)
-	suite.Require().ErrorContains(err, "trusted block hash should not be nil")
-
-	msgRegisterOracle.TrustedBlockHash = suite.trustedBlockHash
-	msgRegisterOracle.OracleCommissionRate = sdk.NewInt(-1).ToDec()
-	err = suite.OracleKeeper.RegisterOracle(ctx, msgRegisterOracle)
-	suite.Require().Error(err, sdkerrors.ErrInvalidRequest)
-	suite.Require().ErrorContains(err, "oracleCommissionRate must be between 0 and OracleCommissionMaxRate")
-
-	msgRegisterOracle.OracleCommissionRate = sdk.NewInt(2).ToDec()
-	err = suite.OracleKeeper.RegisterOracle(ctx, msgRegisterOracle)
-	suite.Require().Error(err, sdkerrors.ErrInvalidRequest)
-	suite.Require().ErrorContains(err, "oracleCommissionRate must be between 0 and OracleCommissionMaxRate")
-
-	events := suite.Ctx.EventManager().Events()
-	suite.Require().Equal(0, len(events))
-}
-
-func (suite *oracleTestSuite) TestRegisterOracleAlreadyExistOracle() {
-	ctx := suite.Ctx
-
-	oracle := types.NewOracle(suite.oracleAccAddr.String(), suite.uniqueID, suite.endpoint, suite.oracleCommissionRate, suite.oracleCommissionMaxRate, suite.oracleCommissionMaxChangeRate, ctx.BlockTime())
-	err := suite.OracleKeeper.SetOracle(ctx, oracle)
 	suite.Require().NoError(err)
 
-	msgRegisterOracle := &types.MsgRegisterOracle{
-		UniqueId:                      suite.uniqueID,
-		OracleAddress:                 suite.oracleAccAddr.String(),
-		NodePubKey:                    suite.nodePubKey.SerializeCompressed(),
-		NodePubKeyRemoteReport:        suite.nodePubKeyRemoteReport,
-		TrustedBlockHeight:            suite.trustedBlockHeight,
-		TrustedBlockHash:              suite.trustedBlockHash,
-		Endpoint:                      suite.endpoint,
-		OracleCommissionRate:          suite.oracleCommissionRate,
-		OracleCommissionMaxRate:       suite.oracleCommissionMaxRate,
-		OracleCommissionMaxChangeRate: suite.oracleCommissionMaxChangeRate,
-	}
-
 	err = suite.OracleKeeper.RegisterOracle(ctx, msgRegisterOracle)
-	suite.Require().Error(err, types.ErrOracleRegistration)
+	suite.Require().Error(err, types.ErrRegisterOracle)
 	suite.Require().ErrorContains(err, fmt.Sprintf("already registered oracle. address(%s)", msgRegisterOracle.OracleAddress))
 }
 
@@ -238,13 +174,17 @@ func (suite *oracleTestSuite) TestRegisterOracleNotSameUniqueID() {
 	}
 
 	err := suite.OracleKeeper.RegisterOracle(ctx, msgRegisterOracle)
-	suite.Require().Error(err, types.ErrOracleRegistration)
-	suite.Require().ErrorContains(err, "is not match the currently active uniqueID")
+	suite.Require().Error(err, types.ErrRegisterOracle)
+	suite.Require().ErrorContains(err, types.ErrInvalidUniqueID.Error())
 }
 
 func (suite *oracleTestSuite) TestApproveOracleRegistrationSuccess() {
 	ctx := suite.Ctx
 
+	oracle := types.NewOracle(suite.oracleAccAddr.String(), suite.uniqueID, suite.endpoint, suite.oracleCommissionRate, suite.oracleCommissionMaxRate, suite.oracleCommissionMaxChangeRate, ctx.BlockTime())
+	err := suite.OracleKeeper.SetOracle(ctx, oracle)
+	suite.Require().NoError(err)
+
 	msgRegisterOracle := &types.MsgRegisterOracle{
 		UniqueId:                      suite.uniqueID,
 		OracleAddress:                 suite.oracleAccAddr.String(),
@@ -258,7 +198,7 @@ func (suite *oracleTestSuite) TestApproveOracleRegistrationSuccess() {
 		OracleCommissionMaxChangeRate: suite.oracleCommissionMaxChangeRate,
 	}
 
-	err := suite.OracleKeeper.RegisterOracle(ctx, msgRegisterOracle)
+	err = suite.OracleKeeper.RegisterOracle(ctx, msgRegisterOracle)
 	suite.Require().NoError(err)
 
 	encryptedOraclePrivKey, err := btcec.Encrypt(suite.nodePubKey, suite.oraclePrivKey.Serialize())
@@ -384,7 +324,7 @@ func (suite *oracleTestSuite) TestApproveOracleRegistrationFailedInvalidSignatur
 	suite.Require().Error(err, "failed to signature validation")
 }
 
-func (suite *oracleTestSuite) TestApproveOracleRegistrationFailedAlreadyExistOracle() {
+func (suite *oracleTestSuite) TestApproveOracleRegistrationFailedAlreadyApprovedOracleRegistration() {
 	ctx := suite.Ctx
 
 	oracle := types.NewOracle(suite.oracleAccAddr.String(), suite.uniqueID, suite.endpoint, suite.oracleCommissionRate, suite.oracleCommissionMaxRate, suite.oracleCommissionMaxChangeRate, ctx.BlockTime())
@@ -405,6 +345,7 @@ func (suite *oracleTestSuite) TestApproveOracleRegistrationFailedAlreadyExistOra
 	}
 
 	oracleRegistration := types.NewOracleRegistration(msgRegisterOracle)
+	oracleRegistration.EncryptedOraclePrivKey = []byte("already registered")
 
 	err = suite.OracleKeeper.SetOracleRegistration(ctx, oracleRegistration)
 	suite.Require().NoError(err)
@@ -426,8 +367,8 @@ func (suite *oracleTestSuite) TestApproveOracleRegistrationFailedAlreadyExistOra
 	msgApproveOracleRegistration := types.NewMsgApproveOracleRegistration(approveOracleRegistration, signature.Serialize())
 
 	err = suite.OracleKeeper.ApproveOracleRegistration(ctx, msgApproveOracleRegistration)
-	suite.Require().Error(err, types.ErrOracleRegistration)
-	suite.Require().ErrorContains(err, fmt.Sprintf("already registered oracle. address(%s)", msgRegisterOracle.OracleAddress))
+	suite.Require().Error(err, types.ErrRegisterOracle)
+	suite.Require().ErrorContains(err, "already approved oracle registration")
 }
 
 func (suite *oracleTestSuite) TestUpdateOracleInfoSuccess() {

x/oracle/keeper/upgrade.go

@@ -156,3 +156,47 @@ func (k Keeper) GetAllOracleUpgradeList(ctx sdk.Context) ([]types.OracleUpgrade,
 
 	return oracleUpgrades, nil
 }
+
+func (k Keeper) ApproveOracleUpgrade(ctx sdk.Context, msg *types.MsgApproveOracleUpgrade) error {
+	// validate approval for oracle upgrade
+	if err := k.validateApprovalSharingOracleKey(ctx, msg.GetApprovalSharingOracleKey(), msg.GetSignature()); err != nil {
+		return sdkerrors.Wrapf(types.ErrApproveOracleUpgrade, err.Error())
+	}
+
+	// get oracle upgrade and upgrade info
+	upgradeInfo, err := k.GetOracleUpgradeInfo(ctx)
+	if err != nil {
+		return sdkerrors.Wrapf(types.ErrApproveOracleUpgrade, err.Error())
+	}
+
+	oracleUpgrade, err := k.GetOracleUpgrade(ctx, upgradeInfo.GetUniqueId(), msg.GetApprovalSharingOracleKey().GetTargetOracleAddress())
+	if err != nil {
+		return sdkerrors.Wrapf(types.ErrApproveOracleUpgrade, err.Error())
+	}
+
+	// if EncryptedOraclePrivKey is already set, return error
+	if oracleUpgrade.EncryptedOraclePrivKey != nil {
+		return sdkerrors.Wrapf(types.ErrApproveOracleUpgrade, "already approved oracle upgrade. if you want to be shared oracle private key again, please upgrade oracle again")
+	}
+
+	// update encrypted oracle private key
+	oracleUpgrade.EncryptedOraclePrivKey = msg.GetApprovalSharingOracleKey().EncryptedOraclePrivKey
+
+	// set oracle upgrade
+	if err := k.SetOracleUpgrade(ctx, oracleUpgrade); err != nil {
+		return sdkerrors.Wrapf(types.ErrApproveOracleUpgrade, err.Error())
+	}
+
+	// emit event
+	ctx.EventManager().EmitEvent(
+		sdk.NewEvent(
+			types.EventTypeApproveOracleUpgrade,
+			sdk.NewAttribute(types.AttributeKeyOracleAddress, msg.GetApprovalSharingOracleKey().GetTargetOracleAddress()),
+			sdk.NewAttribute(types.AttributeKeyUniqueID, upgradeInfo.GetUniqueId()),
+		),
+	)
+
+	// TODO: add to queue(?) for update unique ID
+
+	return nil
+}