github.com/Finschia/finschia-sdk@v0.48.1/x/staking/types/authz_test.go (about)

     1  package types_test
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/require"
     7  	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
     8  
     9  	"github.com/Finschia/finschia-sdk/simapp"
    10  	sdk "github.com/Finschia/finschia-sdk/types"
    11  	stakingtypes "github.com/Finschia/finschia-sdk/x/staking/types"
    12  )
    13  
    14  var (
    15  	coin100 = sdk.NewInt64Coin("steak", 100)
    16  	coin50  = sdk.NewInt64Coin("steak", 50)
    17  	delAddr = sdk.AccAddress("_____delegator _____")
    18  	val1    = sdk.ValAddress("_____validator1_____")
    19  	val2    = sdk.ValAddress("_____validator2_____")
    20  	val3    = sdk.ValAddress("_____validator3_____")
    21  )
    22  
    23  func TestAuthzAuthorizations(t *testing.T) {
    24  	app := simapp.Setup(false)
    25  	ctx := app.BaseApp.NewContext(false, tmproto.Header{})
    26  
    27  	// verify ValidateBasic returns error for the AUTHORIZATION_TYPE_UNSPECIFIED authorization type
    28  	delAuth, err := stakingtypes.NewStakeAuthorization([]sdk.ValAddress{val1, val2}, []sdk.ValAddress{}, stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_UNSPECIFIED, &coin100)
    29  	require.NoError(t, err)
    30  	require.Error(t, delAuth.ValidateBasic())
    31  
    32  	// verify MethodName
    33  	delAuth, err = stakingtypes.NewStakeAuthorization([]sdk.ValAddress{val1, val2}, []sdk.ValAddress{}, stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_DELEGATE, &coin100)
    34  	require.NoError(t, err)
    35  	require.Equal(t, delAuth.MsgTypeURL(), sdk.MsgTypeURL(&stakingtypes.MsgDelegate{}))
    36  
    37  	// error both allow & deny list
    38  	_, err = stakingtypes.NewStakeAuthorization([]sdk.ValAddress{val1, val2}, []sdk.ValAddress{val1}, stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_DELEGATE, &coin100)
    39  	require.Error(t, err)
    40  
    41  	// verify MethodName
    42  	undelAuth, _ := stakingtypes.NewStakeAuthorization([]sdk.ValAddress{val1, val2}, []sdk.ValAddress{}, stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_UNDELEGATE, &coin100)
    43  	require.Equal(t, undelAuth.MsgTypeURL(), sdk.MsgTypeURL(&stakingtypes.MsgUndelegate{}))
    44  
    45  	// verify MethodName
    46  	beginRedelAuth, _ := stakingtypes.NewStakeAuthorization([]sdk.ValAddress{val1, val2}, []sdk.ValAddress{}, stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_REDELEGATE, &coin100)
    47  	require.Equal(t, beginRedelAuth.MsgTypeURL(), sdk.MsgTypeURL(&stakingtypes.MsgBeginRedelegate{}))
    48  
    49  	validators1_2 := []string{val1.String(), val2.String()}
    50  
    51  	testCases := []struct {
    52  		msg                  string
    53  		allowed              []sdk.ValAddress
    54  		denied               []sdk.ValAddress
    55  		msgType              stakingtypes.AuthorizationType
    56  		limit                *sdk.Coin
    57  		srvMsg               sdk.Msg
    58  		expectErr            bool
    59  		isDelete             bool
    60  		updatedAuthorization *stakingtypes.StakeAuthorization
    61  	}{
    62  		{
    63  			"delegate: expect 0 remaining coins",
    64  			[]sdk.ValAddress{val1, val2},
    65  			[]sdk.ValAddress{},
    66  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_DELEGATE,
    67  			&coin100,
    68  			stakingtypes.NewMsgDelegate(delAddr, val1, coin100),
    69  			false,
    70  			true,
    71  			nil,
    72  		},
    73  		{
    74  			"delegate: verify remaining coins",
    75  			[]sdk.ValAddress{val1, val2},
    76  			[]sdk.ValAddress{},
    77  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_DELEGATE,
    78  			&coin100,
    79  			stakingtypes.NewMsgDelegate(delAddr, val1, coin50),
    80  			false,
    81  			false,
    82  			&stakingtypes.StakeAuthorization{
    83  				Validators: &stakingtypes.StakeAuthorization_AllowList{
    84  					AllowList: &stakingtypes.StakeAuthorization_Validators{Address: validators1_2},
    85  				}, MaxTokens: &coin50, AuthorizationType: stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_DELEGATE,
    86  			},
    87  		},
    88  		{
    89  			"delegate: testing with invalid validator",
    90  			[]sdk.ValAddress{val1, val2},
    91  			[]sdk.ValAddress{},
    92  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_DELEGATE,
    93  			&coin100,
    94  			stakingtypes.NewMsgDelegate(delAddr, val3, coin100),
    95  			true,
    96  			false,
    97  			nil,
    98  		},
    99  		{
   100  			"delegate: testing delegate without spent limit",
   101  			[]sdk.ValAddress{val1, val2},
   102  			[]sdk.ValAddress{},
   103  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_DELEGATE,
   104  			nil,
   105  			stakingtypes.NewMsgDelegate(delAddr, val2, coin100),
   106  			false,
   107  			false,
   108  			&stakingtypes.StakeAuthorization{
   109  				Validators: &stakingtypes.StakeAuthorization_AllowList{
   110  					AllowList: &stakingtypes.StakeAuthorization_Validators{Address: validators1_2},
   111  				}, MaxTokens: nil, AuthorizationType: stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_DELEGATE,
   112  			},
   113  		},
   114  		{
   115  			"delegate: fail validator denied",
   116  			[]sdk.ValAddress{},
   117  			[]sdk.ValAddress{val1},
   118  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_DELEGATE,
   119  			nil,
   120  			stakingtypes.NewMsgDelegate(delAddr, val1, coin100),
   121  			true,
   122  			false,
   123  			nil,
   124  		},
   125  		{
   126  			"delegate: testing with a validator out of denylist",
   127  			[]sdk.ValAddress{},
   128  			[]sdk.ValAddress{val1},
   129  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_DELEGATE,
   130  			nil,
   131  			stakingtypes.NewMsgDelegate(delAddr, val2, coin100),
   132  			false,
   133  			false,
   134  			&stakingtypes.StakeAuthorization{
   135  				Validators: &stakingtypes.StakeAuthorization_DenyList{
   136  					DenyList: &stakingtypes.StakeAuthorization_Validators{Address: []string{val1.String()}},
   137  				}, MaxTokens: nil, AuthorizationType: stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_DELEGATE},
   138  		},
   139  		{
   140  			"undelegate: expect 0 remaining coins",
   141  			[]sdk.ValAddress{val1, val2},
   142  			[]sdk.ValAddress{},
   143  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_UNDELEGATE,
   144  			&coin100,
   145  			stakingtypes.NewMsgUndelegate(delAddr, val1, coin100),
   146  			false,
   147  			true,
   148  			nil,
   149  		},
   150  		{
   151  			"undelegate: verify remaining coins",
   152  			[]sdk.ValAddress{val1, val2},
   153  			[]sdk.ValAddress{},
   154  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_UNDELEGATE,
   155  			&coin100,
   156  			stakingtypes.NewMsgUndelegate(delAddr, val1, coin50),
   157  			false,
   158  			false,
   159  			&stakingtypes.StakeAuthorization{
   160  				Validators: &stakingtypes.StakeAuthorization_AllowList{
   161  					AllowList: &stakingtypes.StakeAuthorization_Validators{Address: validators1_2},
   162  				}, MaxTokens: &coin50, AuthorizationType: stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_UNDELEGATE,
   163  			},
   164  		},
   165  		{
   166  			"undelegate: testing with invalid validator",
   167  			[]sdk.ValAddress{val1, val2},
   168  			[]sdk.ValAddress{},
   169  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_UNDELEGATE,
   170  			&coin100,
   171  			stakingtypes.NewMsgUndelegate(delAddr, val3, coin100),
   172  			true,
   173  			false,
   174  			nil,
   175  		},
   176  		{
   177  			"undelegate: testing delegate without spent limit",
   178  			[]sdk.ValAddress{val1, val2},
   179  			[]sdk.ValAddress{},
   180  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_UNDELEGATE,
   181  			nil,
   182  			stakingtypes.NewMsgUndelegate(delAddr, val2, coin100),
   183  			false,
   184  			false,
   185  			&stakingtypes.StakeAuthorization{
   186  				Validators: &stakingtypes.StakeAuthorization_AllowList{
   187  					AllowList: &stakingtypes.StakeAuthorization_Validators{Address: validators1_2},
   188  				}, MaxTokens: nil, AuthorizationType: stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_UNDELEGATE,
   189  			},
   190  		},
   191  		{
   192  			"undelegate: fail cannot undelegate, permission denied",
   193  			[]sdk.ValAddress{},
   194  			[]sdk.ValAddress{val1},
   195  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_UNDELEGATE,
   196  			&coin100,
   197  			stakingtypes.NewMsgUndelegate(delAddr, val1, coin100),
   198  			true,
   199  			false,
   200  			nil,
   201  		},
   202  
   203  		{
   204  			"redelegate: expect 0 remaining coins",
   205  			[]sdk.ValAddress{val1, val2},
   206  			[]sdk.ValAddress{},
   207  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_REDELEGATE,
   208  			&coin100,
   209  			stakingtypes.NewMsgUndelegate(delAddr, val1, coin100),
   210  			false,
   211  			true,
   212  			nil,
   213  		},
   214  		{
   215  			"redelegate: verify remaining coins",
   216  			[]sdk.ValAddress{val1, val2},
   217  			[]sdk.ValAddress{},
   218  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_REDELEGATE,
   219  			&coin100,
   220  			stakingtypes.NewMsgBeginRedelegate(delAddr, val1, val1, coin50),
   221  			false,
   222  			false,
   223  			&stakingtypes.StakeAuthorization{
   224  				Validators: &stakingtypes.StakeAuthorization_AllowList{
   225  					AllowList: &stakingtypes.StakeAuthorization_Validators{Address: validators1_2},
   226  				}, MaxTokens: &coin50, AuthorizationType: stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_REDELEGATE,
   227  			},
   228  		},
   229  		{
   230  			"redelegate: testing with invalid validator",
   231  			[]sdk.ValAddress{val1, val2},
   232  			[]sdk.ValAddress{},
   233  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_REDELEGATE,
   234  			&coin100,
   235  			stakingtypes.NewMsgBeginRedelegate(delAddr, val3, val3, coin100),
   236  			true,
   237  			false,
   238  			nil,
   239  		},
   240  		{
   241  			"redelegate: testing delegate without spent limit",
   242  			[]sdk.ValAddress{val1, val2},
   243  			[]sdk.ValAddress{},
   244  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_REDELEGATE,
   245  			nil,
   246  			stakingtypes.NewMsgBeginRedelegate(delAddr, val2, val2, coin100),
   247  			false,
   248  			false,
   249  			&stakingtypes.StakeAuthorization{
   250  				Validators: &stakingtypes.StakeAuthorization_AllowList{
   251  					AllowList: &stakingtypes.StakeAuthorization_Validators{Address: validators1_2},
   252  				}, MaxTokens: nil, AuthorizationType: stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_REDELEGATE,
   253  			},
   254  		},
   255  		{
   256  			"redelegate: fail cannot undelegate, permission denied",
   257  			[]sdk.ValAddress{},
   258  			[]sdk.ValAddress{val1},
   259  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_REDELEGATE,
   260  			&coin100,
   261  			stakingtypes.NewMsgBeginRedelegate(delAddr, val1, val1, coin100),
   262  			true,
   263  			false,
   264  			nil,
   265  		},
   266  	}
   267  
   268  	for _, tc := range testCases {
   269  		tc := tc
   270  		t.Run(tc.msg, func(t *testing.T) {
   271  			delAuth, err := stakingtypes.NewStakeAuthorization(tc.allowed, tc.denied, tc.msgType, tc.limit)
   272  			require.NoError(t, err)
   273  			resp, err := delAuth.Accept(ctx, tc.srvMsg)
   274  			require.Equal(t, tc.isDelete, resp.Delete)
   275  			if tc.expectErr {
   276  				require.Error(t, err)
   277  			} else {
   278  				require.NoError(t, err)
   279  				if tc.updatedAuthorization != nil {
   280  					require.Equal(t, tc.updatedAuthorization.String(), resp.Updated.String())
   281  				}
   282  			}
   283  		})
   284  	}
   285  }