chore: cleanup

x/authz/keeper/keeper.go

@@ -129,15 +129,15 @@ func (k Keeper) DispatchActions(ctx sdk.Context, grantee sdk.AccAddress, msgs []
 }
 
 // SaveGrant method grants the provided authorization to the grantee on the granter's account
-// with the provided expiration time and insert authorization key into the expired grants queue. If there is an existing authorization grant for the
+// with the provided expiration time and insert authorization key into the grants queue. If there is an existing authorization grant for the
 // same `sdk.Msg` type, this grant overwrites that.
 func (k Keeper) SaveGrant(ctx sdk.Context, grantee, granter sdk.AccAddress, authorization authz.Authorization, expiration time.Time) error {
 	store := ctx.KVStore(k.storeKey)
 	skey := grantStoreKey(grantee, granter, authorization.MsgTypeURL())
 
 	grant, found := k.getGrant(ctx, skey)
 	if found {
-		k.removeFromExpiredGrantQueue(ctx, grantee, granter, authorization.MsgTypeURL(), grant.Expiration)
+		k.removeFromGrantQueue(ctx, skey, grant.Expiration)
 	}
 
 	grant, err := authz.NewGrant(authorization, expiration)
@@ -147,7 +147,7 @@ func (k Keeper) SaveGrant(ctx sdk.Context, grantee, granter sdk.AccAddress, auth
 
 	bz := k.cdc.MustMarshal(&grant)
 	store.Set(skey, bz)
-	k.insertIntoExpiredGrantQueue(ctx, grantee, granter, authorization.MsgTypeURL(), expiration)
+	k.insertIntoGrantQueue(ctx, skey, expiration)
 
 	return ctx.EventManager().EmitTypedEvent(&authz.EventGrant{
 		MsgTypeUrl: authorization.MsgTypeURL(),
@@ -165,8 +165,9 @@ func (k Keeper) DeleteGrant(ctx sdk.Context, grantee sdk.AccAddress, granter sdk
 	if !found {
 		return sdkerrors.ErrNotFound.Wrap("authorization not found")
 	}
+
 	store.Delete(skey)
-	k.removeFromExpiredGrantQueue(ctx, grantee, granter, msgType, grant.Expiration)
+	k.removeFromGrantQueue(ctx, skey, grant.Expiration)
 
 	return ctx.EventManager().EmitTypedEvent(&authz.EventRevoke{
 		MsgTypeUrl: msgType,
@@ -263,36 +264,27 @@ func (k Keeper) InitGenesis(ctx sdk.Context, data *authz.GenesisState) {
 	}
 }
 
-// insertIntoExpiredGrantQueue Inserts a grant key into the expired grant queue
-func (keeper Keeper) insertIntoExpiredGrantQueue(ctx sdk.Context, grantee, granter sdk.AccAddress, msgType string, expiration time.Time) {
+// insertIntoGrantQueue Inserts a grant key into the grant queue
+func (keeper Keeper) insertIntoGrantQueue(ctx sdk.Context, grantKey []byte, expiration time.Time) {
 	store := ctx.KVStore(keeper.storeKey)
-	bz := grantStoreKey(grantee, granter, msgType)
-	store.Set(expiredGrantQueueKey(grantee, granter, msgType, expiration), bz)
+	store.Set(GrantQueueKey(grantKey, expiration), grantKey)
 }
 
-// removeFromExpiredGrantQueue removes a grant key from the expired grant queue
-func (keeper Keeper) removeFromExpiredGrantQueue(ctx sdk.Context, grantee, granter sdk.AccAddress, msgType string, expiration time.Time) {
+// removeFromGrantQueue removes a grant key from the grant queue
+func (keeper Keeper) removeFromGrantQueue(ctx sdk.Context, grantKey []byte, expiration time.Time) {
 	store := ctx.KVStore(keeper.storeKey)
-	store.Delete(expiredGrantQueueKey(grantee, granter, msgType, expiration))
+	store.Delete(GrantQueueKey(grantKey, expiration))
 }
 
-// IterateExpiredGrantQueue iterates over the grants in the expired authorization queue
-// and performs a callback function
-func (keeper Keeper) IterateExpiredGrantQueue(ctx sdk.Context, endTime time.Time, cb func(grantee, granter sdk.AccAddress, msgType string) (stop bool)) {
-	store := ctx.KVStore(keeper.storeKey)
+// DeleteAllMatureGrants deletes expired grants from the queue and deletes grant from the store.
+func (k Keeper) DeleteAllMatureGrants(ctx sdk.Context) {
+	store := ctx.KVStore(k.storeKey)
 
-	iterator := store.Iterator(ExpiredGrantQueuePrefix, sdk.PrefixEndBytes(expiredGrantByTimeKey(endTime)))
+	iterator := store.Iterator(GrantQueuePrefix, sdk.PrefixEndBytes(grantByTimeKey(ctx.BlockTime())))
 	defer iterator.Close()
 
 	for ; iterator.Valid(); iterator.Next() {
-		_, grantee, granter, msgType := splitExpiredGrantQueueKey(iterator.Key())
-		_, found := keeper.getGrant(ctx, grantStoreKey(grantee, granter, msgType))
-		if !found {
-			panic("grant not found")
-		}
-
-		if cb(grantee, granter, msgType) {
-			break
-		}
+		store.Delete(iterator.Key())
+		store.Delete(iterator.Value())
 	}
 }

x/authz/keeper/keeper_test.go

@@ -248,7 +248,7 @@ func (s *TestSuite) TestDispatchedEvents() {
 	}
 }
 
-func (s *TestSuite) TestIterExpiredGrantsQueue() {
+func (s *TestSuite) TestPruneAllGrantsQueue() {
 	require := s.Require()
 	app, addrs := s.app, s.addrs
 	granter := addrs[0]
@@ -269,14 +269,12 @@ func (s *TestSuite) TestIterExpiredGrantsQueue() {
 	err = app.AuthzKeeper.SaveGrant(s.ctx, granter, grantee, &banktypes.SendAuthorization{SpendLimit: smallCoin}, now.AddDate(2, 0, 0))
 	require.NoError(err)
 
-	futureTime := s.ctx.WithBlockTime(now.AddDate(1, 0, 0)).BlockTime()
-	app.AuthzKeeper.IterateExpiredGrantQueue(s.ctx, futureTime, func(gte, gtr sdk.AccAddress, msgType string) (stop bool) {
-		require.Contains([]sdk.AccAddress{grantee, grantee1}, gte)
-		require.Equal(granter, gtr)
-		require.Equal(msgType, bankSendAuthMsgType)
+	ctx := s.ctx.WithBlockTime(now.AddDate(1, 0, 0))
+	app.AuthzKeeper.DeleteAllMatureGrants(ctx)
 
-		return false
-	})
+	require.Len(app.AuthzKeeper.GetAuthorizations(ctx, grantee, granter), 0)
+	require.Len(app.AuthzKeeper.GetAuthorizations(ctx, grantee1, granter), 0)
+	require.Len(app.AuthzKeeper.GetAuthorizations(ctx, granter, granter), 0)
 }
 
 func TestTestSuite(t *testing.T) {

x/authz/keeper/keys.go

@@ -18,8 +18,8 @@ import (
 // - 0x02<grant_expiration_Bytes><grant_Bytes>: grantKey
 //
 var (
-	GrantKey                = []byte{0x01} // prefix for each key
-	ExpiredGrantQueuePrefix = []byte{0x02}
+	GrantKey         = []byte{0x01} // prefix for each key
+	GrantQueuePrefix = []byte{0x02}
 )
 
 var lenTime = len(sdk.FormatTimeBytes(time.Now()))
@@ -61,7 +61,7 @@ func addressesFromGrantStoreKey(key []byte) (granterAddr, granteeAddr sdk.AccAdd
 	return granterAddr, granteeAddr
 }
 
-func splitExpiredGrantQueueKey(key []byte) (expiration time.Time, grantee, granter sdk.AccAddress, msgType string) {
+func splitGrantQueueKey(key []byte) (expiration time.Time, grantee, granter sdk.AccAddress, msgType string) {
 	// key is of format:
 	// 0x02<grant_expiration_Bytes><granterAddressLen (1 Byte)><granterAddress_Bytes><granteeAddressLen (1 Byte)><granteeAddress_Bytes><msgType_Bytes>
 
@@ -83,28 +83,22 @@ func splitExpiredGrantQueueKey(key []byte) (expiration time.Time, grantee, grant
 	return expiration, grantee, granter, msgType
 }
 
-// expiredGrantByTimeKey gets the expired grant queue key by expiration
-func expiredGrantByTimeKey(expiration time.Time) []byte {
-	return append(ExpiredGrantQueuePrefix, sdk.FormatTimeBytes(expiration)...)
+// grantByTimeKey gets the grant queue key by expiration
+func grantByTimeKey(expiration time.Time) []byte {
+	return append(GrantQueuePrefix, sdk.FormatTimeBytes(expiration)...)
 }
 
-// expiredGrantQueueKey - return expired grant queue store key
-// Items are stored with the following key: values
+// GrantQueueKey - return grant queue store key
+// Key format is
 //
 // - 0x02<grant_expiration_Bytes><granterAddressLen (1 Byte)><granterAddress_Bytes><granteeAddressLen (1 Byte)><granteeAddress_Bytes><msgType_Bytes>: grantKey
-func expiredGrantQueueKey(grantee sdk.AccAddress, granter sdk.AccAddress, msgType string, expiration time.Time) []byte {
-	expiredGrantKey := expiredGrantByTimeKey(expiration)
-	expiredGrantKeyLen := len(expiredGrantByTimeKey(expiration))
-
-	m := conv.UnsafeStrToBytes(msgType)
-	granter = address.MustLengthPrefix(granter)
-	grantee = address.MustLengthPrefix(grantee)
+func GrantQueueKey(grantKey []byte, expiration time.Time) []byte {
+	expiredGrantKey := grantByTimeKey(expiration)
+	expiredGrantKeyLen := len(expiredGrantKey)
 
-	l := expiredGrantKeyLen + len(grantee) + len(granter) + len(m)
+	l := len(grantKey) - 1 + expiredGrantKeyLen
 	var key = make([]byte, l)
 	copy(key, expiredGrantKey)
-	copy(key[expiredGrantKeyLen:], granter)
-	copy(key[expiredGrantKeyLen+len(granter):], grantee)
-	copy(key[l-len(m):], m)
+	copy(key[expiredGrantKeyLen:], grantKey[1:])
 	return key
 }

x/authz/keeper/keys_test.go

@@ -26,12 +26,13 @@ func TestGrantkey(t *testing.T) {
 	require.Equal(grantee, grantee1)
 }
 
-func TestExpiredQueueKey(t *testing.T) {
+func TestGrantQueueKey(t *testing.T) {
 	blockTime := time.Now().UTC()
+	key := grantStoreKey(grantee, granter, msgType)
 
-	key := expiredGrantQueueKey(grantee, granter, msgType, blockTime)
+	queueKey := GrantQueueKey(key, blockTime)
 
-	expiration, grantee1, granter1, authzType := splitExpiredGrantQueueKey(key)
+	expiration, grantee1, granter1, authzType := splitGrantQueueKey(queueKey)
 
 	require.Equal(t, blockTime, expiration)
 	require.Equal(t, granter, granter1)

x/authz/module/abci.go

@@ -5,12 +5,9 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/authz/keeper"
 )
 
-// EndBlocker prunes expired authorizations from the state
+// EndBlocker is called at the end of every block
 func EndBlocker(ctx sdk.Context, keeper keeper.Keeper) {
 
-	// delete expired authorizations from store
-	keeper.IterateExpiredGrantQueue(ctx, ctx.BlockHeader().Time, func(grantee, granter sdk.AccAddress, msgType string) (stop bool) {
-		keeper.DeleteGrant(ctx, grantee, granter, msgType)
-		return false
-	})
+	// clears all the mature grants
+	keeper.DeleteAllMatureGrants(ctx)
 }

x/authz/module/module.go

@@ -153,7 +153,7 @@ func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.Raw
 }
 
 // ConsensusVersion implements AppModule/ConsensusVersion.
-func (AppModule) ConsensusVersion() uint64 { return 1 }
+func (AppModule) ConsensusVersion() uint64 { return 2 }
 
 func (am AppModule) BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock) {}