feat: add role-based access control for bridge

docs/core/proto-docs.md

@@ -12703,7 +12703,7 @@ MsgTransfer is input values required for bridge transfer
 | `Claim` | [MsgClaim](#lbm.fbridge.v1.MsgClaim) | [MsgClaimResponse](#lbm.fbridge.v1.MsgClaimResponse) | Claim processes the claiming of a provision with a specific sequence number | |
 | `SuggestRole` | [MsgSuggestRole](#lbm.fbridge.v1.MsgSuggestRole) | [MsgSuggestRoleResponse](#lbm.fbridge.v1.MsgSuggestRoleResponse) | SuggestRole suggests updating the role of an address in the bridge module. The role can be one of the following: guardian, operator, judge. The proposal will be passed only with the consent of +2/3 Guardian members. | |
 | `AddVoteForRole` | [MsgAddVoteForRole](#lbm.fbridge.v1.MsgAddVoteForRole) | [MsgAddVoteForRoleResponse](#lbm.fbridge.v1.MsgAddVoteForRoleResponse) | AddVoteForRole adds a vote for a role change proposal. | |
-| `SetBridgeStatus` | [MsgSetBridgeStatus](#lbm.fbridge.v1.MsgSetBridgeStatus) | [MsgSetBridgeStatusResponse](#lbm.fbridge.v1.MsgSetBridgeStatusResponse) | SetBridgeStatus operates a switch to halt/resume the bridge module. If the ratio of active bridge switches does not exceed TrustLevel, the bridge module halts. | |
+| `SetBridgeStatus` | [MsgSetBridgeStatus](#lbm.fbridge.v1.MsgSetBridgeStatus) | [MsgSetBridgeStatusResponse](#lbm.fbridge.v1.MsgSetBridgeStatusResponse) | SetBridgeStatus operates a switch to halt/resume the bridge module. If the ratio of inactive bridge switches exceed TrustLevel, the bridge module halts. | |
 
  <!-- end services -->
 

proto/lbm/fbridge/v1/fbridge.proto

@@ -118,6 +118,7 @@ enum BridgeStatus {
 
   // BRIDGE_STATUS_UNSPECIFIED defines an unspecified bridge status.
   BRIDGE_STATUS_UNSPECIFIED = 0 [(gogoproto.enumvalue_customname) = "StatusEmpty"];
+
   // BRIDGE_STATUS_ACTIVE defines an active bridge status.
   BRIDGE_STATUS_ACTIVE = 1 [(gogoproto.enumvalue_customname) = "StatusActive"];
   // BRIDGE_STATUS_INACTIVE defines an inactive bridge status.

proto/lbm/fbridge/v1/tx.proto

@@ -37,7 +37,7 @@ service Msg {
   rpc AddVoteForRole(MsgAddVoteForRole) returns (MsgAddVoteForRoleResponse);
 
   // SetBridgeStatus operates a switch to halt/resume the bridge module.
-  // If the ratio of active bridge switches does not exceed TrustLevel, the bridge module halts.
+  // If the ratio of inactive bridge switches exceed TrustLevel, the bridge module halts.
   rpc SetBridgeStatus(MsgSetBridgeStatus) returns (MsgSetBridgeStatusResponse);
 }
 

x/fbridge/keeper/abci.go

@@ -7,61 +7,71 @@
 	"github.com/Finschia/finschia-sdk/x/fbridge/types"
 )
 
 func (k Keeper) BeginBlocker(ctx sdk.Context) {
 	k.InitMemStore(ctx)
 
 	proposals := k.GetRoleProposals(ctx)
 	for _, proposal := range proposals {
 		if ctx.BlockTime().After(proposal.ExpiredAt) {
 			k.deleteRoleProposal(ctx, proposal.Id)
 		}
 	}
 }
 
 func (k Keeper) EndBlocker(ctx sdk.Context) {
 	guardianTrustLevel := k.GetParams(ctx).GuardianTrustLevel
 	proposals := k.GetRoleProposals(ctx)
 	for _, proposal := range proposals {
 		votes := k.GetProposalVotes(ctx, proposal.Id)
 
 		var voteYes uint64 = 0
 		for _, vote := range votes {
 			if vote.Option == types.OptionYes {
 				voteYes++
 			}
 		}
 
 		if types.CheckTrustLevelThreshold(k.GetRoleMetadata(ctx).Guardian, voteYes, guardianTrustLevel) || proposal.Proposer == k.GetAuthority() {
 			if err := k.updateRole(ctx, proposal.Role, sdk.MustAccAddressFromBech32(proposal.Target)); err != nil {
 				panic(err)
 			}
 
 			k.deleteRoleProposal(ctx, proposal.Id)
 		}
 	}
 }
 
 // RegisterInvariants registers the fbridge module invariants
 func RegisterInvariants(ir sdk.InvariantRegistry, k Keeper) {
 	ir.RegisterRoute(types.ModuleName, "guardian-invariant", GuardianInvariant(k))
 }
 
 func GuardianInvariant(k Keeper) sdk.Invariant {
 	return func(ctx sdk.Context) (string, bool) {
 		numGuardian := 0
 		for _, p := range k.GetRolePairs(ctx) {
 			if p.Role == types.RoleGuardian {
 				numGuardian++
 			}
 		}
 
 		numBridgeSw := len(k.GetBridgeSwitches(ctx))
+		if numGuardian != numBridgeSw {
+			return sdk.FormatInvariant(
+				types.ModuleName, "guardian-invariant",
+				fmt.Sprintf("number of guardians(%d) != number of bridge switches(%d)", numGuardian, numBridgeSw),
+			), true
+		}
 
-		broken := numGuardian != numBridgeSw
+		bsMeta := k.GetBridgeStatusMetadata(ctx)
+		roleMeta := k.GetRoleMetadata(ctx)
+		if (bsMeta.Inactive + bsMeta.Active) != roleMeta.Guardian {
+			return sdk.FormatInvariant(
+				types.ModuleName, "guardian-invariant",
+				fmt.Sprintf("Bridge status metadata (%+v) does not match with guardian role metadata(%d)", bsMeta, roleMeta.Guardian),
+			), true
+		}
 
-		return sdk.FormatInvariant(
-			types.ModuleName, "guardian-invariant",
-			fmt.Sprintf("number of guardians(%d) != number of bridge switches(%d)", numGuardian, numBridgeSw),
-		), broken
+		return sdk.FormatInvariant(types.ModuleName, "guardian-invariant", ""), false
 	}
 }

x/fbridge/keeper/auth.go

@@ -22,7 +22,7 @@
 	}
 
 	if k.GetRole(ctx, target) == role {
 		return types.RoleProposal{}, sdkerrors.ErrUnauthorized.Wrap("target already has same role")
 	}
 
 	proposalID := k.GetNextProposalID(ctx)
@@ -42,16 +42,16 @@
 
 func (k Keeper) addVote(ctx sdk.Context, proposalID uint64, voter sdk.AccAddress, option types.VoteOption) error {
 	if k.GetRole(ctx, voter) != types.RoleGuardian {
 		return sdkerrors.ErrUnauthorized.Wrap("only guardian can execute this action")
 	}
 
 	_, found := k.GetRoleProposal(ctx, proposalID)
 	if !found {
 		return types.ErrUnknownProposal.Wrapf("#%d not found", proposalID)
 	}
 
 	if err := types.IsValidVoteOption(option); err != nil {
-		return err
+		return sdkerrors.ErrInvalidRequest.Wrap(err.Error())
 	}
 
 	k.setVote(ctx, proposalID, voter, option)
@@ -66,82 +66,76 @@
 	}
 
 	roleMeta := k.GetRoleMetadata(ctx)
-	bsMeta := k.GetBridgeStatusMetadata(ctx)
+	nInactive := k.GetBridgeInactiveCounter(ctx)
 
 	switch previousRole {
 	case types.RoleGuardian:
 		roleMeta.Guardian--
 
-		sw, err := k.GetBridgeSwitch(ctx, addr)
+		bs, err := k.GetBridgeSwitch(ctx, addr)
 		if err != nil {
-			panic(err)
+			return err
 		}
 
-		switch sw.Status {
-		case types.StatusActive:
-			bsMeta.Active--
-		case types.StatusInactive:
-			bsMeta.Inactive--
-		default:
-			return sdkerrors.ErrInvalidRequest.Wrap("invalid bridge switch status")
+		if bs.Status == types.StatusInactive {
+			nInactive--
 		}
 
 		k.deleteBridgeSwitch(ctx, addr)
 
 	case types.RoleOperator:
 		roleMeta.Operator--
 	case types.RoleJudge:
 		roleMeta.Judge--
 	}
 
 	if role == types.RoleEmpty {
 		k.deleteRole(ctx, addr)
 		return nil
 	} else {
-		k.setRole(ctx, role, addr)
+		if err := k.setRole(ctx, role, addr); err != nil {
+			return err
+		}
 	}
 
 	switch role {
 	case types.RoleGuardian:
 		roleMeta.Guardian++
 		if err := k.setBridgeSwitch(ctx, addr, types.StatusActive); err != nil {
 			panic(err)
 		}
-		bsMeta.Active++
 	case types.RoleOperator:
 		roleMeta.Operator++
 	case types.RoleJudge:
 		roleMeta.Judge++
 	}
 
 	k.setRoleMetadata(ctx, roleMeta)
-	k.setBridgeStatusMetadata(ctx, bsMeta)
+	k.setBridgeInactiveCounter(ctx, nInactive)
 
 	return nil
 }
 
 func (k Keeper) updateBridgeSwitch(ctx sdk.Context, guardian sdk.AccAddress, status types.BridgeStatus) error {
 	if sw, err := k.GetBridgeSwitch(ctx, guardian); err == nil && sw.Status == status {
 		return sdkerrors.ErrInvalidRequest.Wrapf("%s already set %s", guardian, status)
 	} else if err != nil {
 		return err
 	}
 
-	bsMeta := k.GetBridgeStatusMetadata(ctx)
+	nInactive := k.GetBridgeInactiveCounter(ctx)
 	switch status {
 	case types.StatusActive:
-		bsMeta.Active++
-		bsMeta.Inactive--
+		nInactive--
 	case types.StatusInactive:
-		bsMeta.Inactive++
-		bsMeta.Active--
+		nInactive++
 	default:
-		return sdkerrors.ErrInvalidRequest.Wrap("invalid bridge switch status")
+		return sdkerrors.ErrInvalidRequest.Wrapf("unknown bridge status: %d", status)
 	}
-	k.setBridgeStatusMetadata(ctx, bsMeta)
+	k.setBridgeInactiveCounter(ctx, nInactive)
 
 	if err := k.setBridgeSwitch(ctx, guardian, status); err != nil {
 		return err
 	}
 
 	return nil
@@ -158,7 +152,7 @@
 	store := ctx.KVStore(k.storeKey)
 	bz := store.Get(types.KeyNextProposalID)
 	if bz == nil {
 		panic("next role proposal ID must be set at genesis")
 	}
 
 	return binary.BigEndian.Uint64(bz)
@@ -174,44 +168,44 @@
 	store := ctx.KVStore(k.storeKey)
 	bz := store.Get(types.ProposalKey(id))
 	if bz == nil {
 		return proposal, false
 	}
 
 	k.cdc.MustUnmarshal(bz, &proposal)
 	return proposal, true
 }
 
 func (k Keeper) deleteRoleProposal(ctx sdk.Context, id uint64) {
 	store := ctx.KVStore(k.storeKey)
 	if _, found := k.GetRoleProposal(ctx, id); !found {
 		panic(fmt.Sprintf("role proposal #%d not found", id))
 	}
 	store.Delete(types.ProposalKey(id))
 }
 
 // IterateProposals iterates over the all the role proposals and performs a callback function
 func (k Keeper) IterateProposals(ctx sdk.Context, cb func(proposal types.RoleProposal) (stop bool)) {
 	store := ctx.KVStore(k.storeKey)
 
 	iterator := sdk.KVStorePrefixIterator(store, types.KeyProposalPrefix)
 	defer iterator.Close()
 
 	for ; iterator.Valid(); iterator.Next() {
 		var proposal types.RoleProposal
 		k.cdc.MustUnmarshal(iterator.Value(), &proposal)
 		if cb(proposal) {
 			break
 		}
 	}
 }
 
 // GetRoleProposals returns all the role proposals from store
 func (k Keeper) GetRoleProposals(ctx sdk.Context) (proposals []types.RoleProposal) {
 	k.IterateProposals(ctx, func(proposal types.RoleProposal) bool {
 		proposals = append(proposals, proposal)
 		return false
 	})
 	return
 }
 
 func (k Keeper) setVote(ctx sdk.Context, proposalID uint64, voter sdk.AccAddress, option types.VoteOption) {
@@ -225,36 +219,42 @@
 	store := ctx.KVStore(k.storeKey)
 	bz := store.Get(types.VoterVoteKey(proposalID, voter))
 	if bz == nil {
 		return types.OptionEmpty, types.ErrUnknownVote
 	}
 
 	return types.VoteOption(binary.BigEndian.Uint32(bz)), nil
 }
 
 func (k Keeper) GetProposalVotes(ctx sdk.Context, proposalID uint64) []types.Vote {
 	store := ctx.KVStore(k.storeKey)
 
 	votes := make([]types.Vote, 0)
 	iterator := sdk.KVStorePrefixIterator(store, types.VotesKey(proposalID))
 	defer iterator.Close()
 	for ; iterator.Valid(); iterator.Next() {
 		_, voter := types.SplitVoterVoteKey(iterator.Key())
 		v := types.Vote{
 			ProposalId: proposalID,
 			Voter:      voter.String(),
 			Option:     types.VoteOption(binary.BigEndian.Uint32(iterator.Value())),
 		}
 		votes = append(votes, v)
 	}
 
 	return votes
 }
 
-func (k Keeper) setRole(ctx sdk.Context, role types.Role, addr sdk.AccAddress) {
+func (k Keeper) setRole(ctx sdk.Context, role types.Role, addr sdk.AccAddress) error {
+	if err := types.IsValidRole(role); err != nil {
+		return sdkerrors.ErrInvalidRequest.Wrap(err.Error())
+	}
+
 	store := ctx.KVStore(k.storeKey)
 	bz := make([]byte, 4)
 	binary.BigEndian.PutUint32(bz, uint32(role))
 	store.Set(types.RoleKey(addr), bz)
+
+	return nil
 }
 
 func (k Keeper) GetRole(ctx sdk.Context, addr sdk.AccAddress) types.Role {
@@ -273,19 +273,23 @@
 	iterator := sdk.KVStorePrefixIterator(store, types.KeyRolePrefix)
 	defer iterator.Close()
 	for ; iterator.Valid(); iterator.Next() {
 		assignee := types.SplitRoleKey(iterator.Key())
 		pairs = append(pairs, types.RolePair{Address: assignee.String(), Role: types.Role(binary.BigEndian.Uint32(iterator.Value()))})
 	}
 
 	return pairs
 }
 
 func (k Keeper) deleteRole(ctx sdk.Context, addr sdk.AccAddress) {
 	store := ctx.KVStore(k.storeKey)
 	store.Delete(types.RoleKey(addr))
 }
 
 func (k Keeper) setBridgeSwitch(ctx sdk.Context, guardian sdk.AccAddress, status types.BridgeStatus) error {
+	if err := types.IsValidBridgeStatus(status); err != nil {
+		return sdkerrors.ErrInvalidRequest.Wrap(err.Error())
+	}
+
 	store := ctx.KVStore(k.storeKey)
 	bz := make([]byte, 4)
 	binary.BigEndian.PutUint32(bz, uint32(status))
@@ -300,13 +304,13 @@
 
 func (k Keeper) GetBridgeSwitch(ctx sdk.Context, guardian sdk.AccAddress) (types.BridgeSwitch, error) {
 	if k.GetRole(ctx, guardian) != types.RoleGuardian {
 		return types.BridgeSwitch{}, sdkerrors.ErrUnauthorized.Wrap("only guardian has bridge switch")
 	}
 
 	store := ctx.KVStore(k.storeKey)
 	bz := store.Get(types.BridgeSwitchKey(guardian))
 	if bz == nil {
 		panic("bridge switch must be set at genesis")
 	}
 
 	return types.BridgeSwitch{Guardian: guardian.String(), Status: types.BridgeStatus(binary.BigEndian.Uint32(bz))}, nil

x/fbridge/keeper/auth_test.go

@@ -86,5 +86,4 @@ func TestBridgeHaltAndResume(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, types.StatusActive, k.GetBridgeStatus(ctx), "bridge status must be active (2/3)")
 	require.Equal(t, types.BridgeStatusMetadata{Active: 2, Inactive: 1}, k.GetBridgeStatusMetadata(ctx))
-
 }

x/fbridge/keeper/genesis.go

@@ -15,22 +15,24 @@
 	}
 
 	for _, pair := range gs.Roles {
-		k.setRole(ctx, pair.Role, sdk.MustAccAddressFromBech32(pair.Address))
+		if err := k.setRole(ctx, pair.Role, sdk.MustAccAddressFromBech32(pair.Address)); err != nil {
+			panic(err)
+		}
 	}
 
 	for _, sw := range gs.BridgeSwitches {
 		if err := k.setBridgeSwitch(ctx, sdk.MustAccAddressFromBech32(sw.Guardian), sw.Status); err != nil {
 			panic(err)
 		}
 	}
 
 	k.setNextProposalID(ctx, gs.NextRoleProposalId)
 	for _, proposal := range gs.RoleProposals {
 		k.setRoleProposal(ctx, proposal)
 	}
 
 	for _, vote := range gs.Votes {
 		k.setVote(ctx, vote.ProposalId, sdk.MustAccAddressFromBech32(vote.Voter), vote.Option)
 	}
 
 	// TODO: we initialize the appropriate genesis parameters whenever the feature is added
@@ -42,17 +44,17 @@
 
 func (k Keeper) ExportGenesis(ctx sdk.Context) *types.GenesisState {
 	return &types.GenesisState{
 		Params: k.GetParams(ctx),
 		SendingState: types.SendingState{
 			NextSeq:       k.GetNextSequence(ctx),
 			SeqToBlocknum: k.getAllSeqToBlocknums(ctx),
 		},
 		ReceivingState:     types.ReceivingState{},
 		NextRoleProposalId: k.GetNextProposalID(ctx),
 		RoleProposals:      k.GetRoleProposals(ctx),
 		Votes:              k.GetAllVotes(ctx),
 		Roles:              k.GetRolePairs(ctx),
 		BridgeSwitches:     k.GetBridgeSwitches(ctx),
 	}
 }
 
@@ -73,26 +75,26 @@
 }
 
 // IterateVotes iterates over the all the votes for role proposals and performs a callback function
 func (k Keeper) IterateVotes(ctx sdk.Context, cb func(proposal types.Vote) (stop bool)) {
 	store := ctx.KVStore(k.storeKey)
 
 	iterator := sdk.KVStorePrefixIterator(store, types.KeyProposalVotePrefix)
 	defer iterator.Close()
 	for ; iterator.Valid(); iterator.Next() {
 		id, voter := types.SplitVoterVoteKey(iterator.Key())
 		opt := types.VoteOption(binary.BigEndian.Uint32(iterator.Value()))
 		v := types.Vote{ProposalId: id, Voter: voter.String(), Option: opt}
 		if cb(v) {
 			break
 		}
 	}
 }
 
 // GetAllVotes returns all the votes from the store
 func (k Keeper) GetAllVotes(ctx sdk.Context) (votes []types.Vote) {
 	k.IterateVotes(ctx, func(vote types.Vote) bool {
 		votes = append(votes, vote)
 		return false
 	})
 	return
 }

x/fbridge/keeper/keeper.go

@@ -1,6 +1,7 @@
 package keeper
 
 import (
+	"encoding/binary"
 	"errors"
 	"fmt"
 
@@ -40,7 +41,7 @@
 		if authority == addr.String() {
 			break
 		}
 		panic("x/bridge authority must be the gov or foundation module account")
 	}
 
 	return Keeper{
@@ -62,7 +63,7 @@
 	memStore := ctx.KVStore(k.memKey)
 	memStoreType := memStore.GetStoreType()
 	if memStoreType != sdk.StoreTypeMemory {
 		panic(fmt.Sprintf("invalid memory store type; got %s, expected: %s", memStoreType, sdk.StoreTypeMemory))
 	}
 
 	// create context with no block gas meter to ensure we do not consume gas during local initialization logic.
@@ -71,29 +72,19 @@
 	roleMetadata := types.RoleMetadata{}
 	if !k.IsInitialized(noGasCtx) {
 		for _, pair := range k.GetRolePairs(noGasCtx) {
 			switch pair.Role {
 			case types.RoleGuardian:
 				roleMetadata.Guardian++
 			case types.RoleOperator:
 				roleMetadata.Operator++
 			case types.RoleJudge:
 				roleMetadata.Judge++
 			}
 		}
 		k.setRoleMetadata(noGasCtx, roleMetadata)
 
-		bsMeta := types.BridgeStatusMetadata{Inactive: 0, Active: 0}
-		for _, bs := range k.GetBridgeSwitches(noGasCtx) {
-			switch bs.Status {
-			case types.StatusInactive:
-				bsMeta.Inactive++
-			case types.StatusActive:
-				bsMeta.Active++
-			default:
-				panic("invalid bridge switch status")
-			}
-		}
-		k.setBridgeStatusMetadata(noGasCtx, types.BridgeStatusMetadata{})
+		nInactive := k.GetBridgeInactiveCounter(noGasCtx)
+		k.setBridgeInactiveCounter(noGasCtx, nInactive)
 
 		memStore := noGasCtx.KVStore(k.memKey)
 		memStore.Set(types.KeyMemInitialized, []byte{1})
@@ -110,8 +101,8 @@
 	return k.authority
 }
 
 func (k Keeper) IsBridgeHalted(ctx sdk.Context) bool {
 	return k.GetBridgeStatus(ctx) == types.StatusInactive
 }
 
 func (k Keeper) setRoleMetadata(ctx sdk.Context, data types.RoleMetadata) {
@@ -125,37 +116,48 @@
 	data := types.RoleMetadata{}
 	bz := memStore.Get(types.KeyMemRoleMetadata)
 	if bz == nil {
 		return types.RoleMetadata{}
 	}
 	k.cdc.MustUnmarshal(bz, &data)
 	return data
 }
 
 func (k Keeper) GetBridgeStatus(ctx sdk.Context) types.BridgeStatus {
-	memStore := ctx.KVStore(k.memKey)
-	bsMeta := types.BridgeStatusMetadata{}
-	bz := memStore.Get(types.KeyMemBridgeStatus)
-	k.cdc.MustUnmarshal(bz, &bsMeta)
-
-	if types.CheckTrustLevelThreshold(bsMeta.Active+bsMeta.Inactive, bsMeta.Active, k.GetParams(ctx).GuardianTrustLevel) {
-		return types.StatusActive
+	roleMeta := k.GetRoleMetadata(ctx)
+	bsMeta := k.GetBridgeStatusMetadata(ctx)
+	if types.CheckTrustLevelThreshold(roleMeta.Guardian, bsMeta.Inactive, k.GetParams(ctx).GuardianTrustLevel) {
+		return types.StatusInactive
 	}
 
-	return types.StatusInactive
+	return types.StatusActive
 }
 
-func (k Keeper) setBridgeStatusMetadata(ctx sdk.Context, status types.BridgeStatusMetadata) {
+func (k Keeper) setBridgeInactiveCounter(ctx sdk.Context, nInactive uint64) {
 	memStore := ctx.KVStore(k.memKey)
-	memStore.Set(types.KeyMemBridgeStatus, k.cdc.MustMarshal(&status))
+	bz := make([]byte, 8)
+	binary.BigEndian.PutUint64(bz, nInactive)
+	memStore.Set(types.KeyMemBridgeInactiveCounter, bz)
 }
 
-func (k Keeper) GetBridgeStatusMetadata(ctx sdk.Context) types.BridgeStatusMetadata {
+func (k Keeper) GetBridgeInactiveCounter(ctx sdk.Context) uint64 {
 	memStore := ctx.KVStore(k.memKey)
-	bsMeta := types.BridgeStatusMetadata{}
-	bz := memStore.Get(types.KeyMemBridgeStatus)
+	bz := memStore.Get(types.KeyMemBridgeInactiveCounter)
 	if bz == nil {
-		return types.BridgeStatusMetadata{}
+		n := uint64(0)
+		for _, bs := range k.GetBridgeSwitches(ctx) {
+			if bs.Status == types.StatusInactive {
+				n++
+			}
+		}
+		return n
 	}
-	k.cdc.MustUnmarshal(bz, &bsMeta)
+
+	return binary.BigEndian.Uint64(bz)
+}
+
+func (k Keeper) GetBridgeStatusMetadata(ctx sdk.Context) types.BridgeStatusMetadata {
+	bsMeta := types.BridgeStatusMetadata{}
+	bsMeta.Inactive = k.GetBridgeInactiveCounter(ctx)
+	bsMeta.Active = k.GetRoleMetadata(ctx).Guardian - bsMeta.Inactive
 	return bsMeta
 }

x/fbridge/keeper/msg_server.go

@@ -21,8 +21,8 @@
 func (m msgServer) Transfer(goCtx context.Context, msg *types.MsgTransfer) (*types.MsgTransferResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
 	if m.IsBridgeHalted(ctx) {
 		return nil, types.ErrInactiveBridge
 	}
 
 	from, err := sdk.AccAddressFromBech32(msg.Sender)
@@ -75,75 +75,71 @@
 	panic("implement me")
 }
 
 func (m msgServer) SuggestRole(goCtx context.Context, msg *types.MsgSuggestRole) (*types.MsgSuggestRoleResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
 	proposer, err := sdk.AccAddressFromBech32(msg.From)
 	if err != nil {
 		return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid proposer address (%s)", err)
 	}
 
 	target, err := sdk.AccAddressFromBech32(msg.Target)
 	if err != nil {
 		return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid target address (%s)", err)
 	}
 
 	if err := types.IsValidRole(msg.Role); err != nil {
 		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, err.Error())
 	}
 
 	proposal, err := m.RegisterRoleProposal(ctx, proposer, target, msg.Role)
 	if err != nil {
 		return nil, err
 	}
 
 	if err := ctx.EventManager().EmitTypedEvent(&types.EventSuggestRole{
 		Proposal: proposal,
 	}); err != nil {
 		panic(err)
 	}
 
 	return &types.MsgSuggestRoleResponse{}, nil
 }
 
 func (m msgServer) AddVoteForRole(goCtx context.Context, msg *types.MsgAddVoteForRole) (*types.MsgAddVoteForRoleResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
 	voter, err := sdk.AccAddressFromBech32(msg.From)
 	if err != nil {
 		return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid proposer address (%s)", err)
 	}
 
-	if err := types.IsValidVoteOption(msg.Option); err != nil {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, err.Error())
-	}
-
 	if err := m.addVote(ctx, msg.ProposalId, voter, msg.Option); err != nil {
 		return nil, err
 	}
 
 	if err := ctx.EventManager().EmitTypedEvent(&types.EventAddVoteForRole{
 		Voter:      msg.From,
 		ProposalId: msg.ProposalId,
 		Option:     msg.Option,
 	}); err != nil {
 		panic(err)
 	}
 
 	return &types.MsgAddVoteForRoleResponse{}, nil
 }
 
 func (m msgServer) SetBridgeStatus(goCtx context.Context, msg *types.MsgSetBridgeStatus) (*types.MsgSetBridgeStatusResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
 	addr, err := sdk.AccAddressFromBech32(msg.Guardian)
 	if err != nil {
 		return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid guardian address (%s)", err)
 	}
 
 	if err := m.updateBridgeSwitch(ctx, addr, msg.Status); err != nil {
 		return nil, err
 	}
 
 	return &types.MsgSetBridgeStatusResponse{}, nil
 }

x/fbridge/types/keys.go

@@ -44,9 +44,9 @@
 	KeyRolePrefix         = []byte{0x13} // key prefix for the role of an address
 	KeyBridgeSwitchPrefix = []byte{0x14} // key for the switch to halt
 
-	KeyMemInitialized  = []byte{0xF0}
-	KeyMemRoleMetadata = []byte{0xF1} // key for the role metadata
-	KeyMemBridgeStatus = []byte{0xF2} // key for the bridge status
+	KeyMemInitialized           = []byte{0xF0}
+	KeyMemRoleMetadata          = []byte{0xF1} // key for the role metadata
+	KeyMemBridgeInactiveCounter = []byte{0xF2} // key for the bridge inactive status
 )
 
 func SeqToBlocknumKey(seq uint64) []byte {
@@ -56,52 +56,52 @@
 }
 
 // GetProposalIDBytes returns the byte representation of the proposalID
 func GetProposalIDBytes(proposalID uint64) []byte {
 	bz := make([]byte, 8)
 	binary.BigEndian.PutUint64(bz, proposalID)
 	return bz
 }
 
 // ProposalKey key of a specific role proposal
 func ProposalKey(proposalID uint64) []byte {
 	return append(KeyProposalPrefix, GetProposalIDBytes(proposalID)...)
 }
 
 // VotesKey gets the first part of the votes key based on the proposalID
 func VotesKey(proposalID uint64) []byte {
 	return append(KeyProposalVotePrefix, GetProposalIDBytes(proposalID)...)
 }
 
 // VoterVoteKey key of a specific vote from the store
 func VoterVoteKey(proposalID uint64, voterAddr sdk.AccAddress) []byte {
 	return append(VotesKey(proposalID), address.MustLengthPrefix(voterAddr.Bytes())...)
 }
 
 // SplitVoterVoteKey split the voter key and returns the proposal id and voter address
 func SplitVoterVoteKey(key []byte) (uint64, sdk.AccAddress) {
 	kv.AssertKeyAtLeastLength(key, 11)
 	proposalID := binary.BigEndian.Uint64(key[1:9])
 	voter := sdk.AccAddress(key[10:])
 	return proposalID, voter
 }
 
 // RoleKey key of a specific role of the address from the store
 func RoleKey(target sdk.AccAddress) []byte {
 	return append(KeyRolePrefix, address.MustLengthPrefix(target.Bytes())...)
 }
 
 // SplitRoleKey split the role key and returns the address
 func SplitRoleKey(key []byte) sdk.AccAddress {
 	kv.AssertKeyAtLeastLength(key, 3)
 	return key[2:]
 }
 
 func BridgeSwitchKey(guardian sdk.AccAddress) []byte {
 	return append(KeyBridgeSwitchPrefix, address.MustLengthPrefix(guardian.Bytes())...)
 }
 
 // SplitBridgeSwitchKey split the bridge switch key and returns the guardian address
 func SplitBridgeSwitchKey(key []byte) sdk.AccAddress {
 	kv.AssertKeyAtLeastLength(key, 3)
 	return key[2:]
 }