github.com/Finschia/finschia-sdk@v0.49.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  		{
   141  			"undelegate: expect 0 remaining coins",
   142  			[]sdk.ValAddress{val1, val2},
   143  			[]sdk.ValAddress{},
   144  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_UNDELEGATE,
   145  			&coin100,
   146  			stakingtypes.NewMsgUndelegate(delAddr, val1, coin100),
   147  			false,
   148  			true,
   149  			nil,
   150  		},
   151  		{
   152  			"undelegate: verify remaining coins",
   153  			[]sdk.ValAddress{val1, val2},
   154  			[]sdk.ValAddress{},
   155  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_UNDELEGATE,
   156  			&coin100,
   157  			stakingtypes.NewMsgUndelegate(delAddr, val1, coin50),
   158  			false,
   159  			false,
   160  			&stakingtypes.StakeAuthorization{
   161  				Validators: &stakingtypes.StakeAuthorization_AllowList{
   162  					AllowList: &stakingtypes.StakeAuthorization_Validators{Address: validators1_2},
   163  				}, MaxTokens: &coin50, AuthorizationType: stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_UNDELEGATE,
   164  			},
   165  		},
   166  		{
   167  			"undelegate: testing with invalid validator",
   168  			[]sdk.ValAddress{val1, val2},
   169  			[]sdk.ValAddress{},
   170  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_UNDELEGATE,
   171  			&coin100,
   172  			stakingtypes.NewMsgUndelegate(delAddr, val3, coin100),
   173  			true,
   174  			false,
   175  			nil,
   176  		},
   177  		{
   178  			"undelegate: testing delegate without spent limit",
   179  			[]sdk.ValAddress{val1, val2},
   180  			[]sdk.ValAddress{},
   181  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_UNDELEGATE,
   182  			nil,
   183  			stakingtypes.NewMsgUndelegate(delAddr, val2, coin100),
   184  			false,
   185  			false,
   186  			&stakingtypes.StakeAuthorization{
   187  				Validators: &stakingtypes.StakeAuthorization_AllowList{
   188  					AllowList: &stakingtypes.StakeAuthorization_Validators{Address: validators1_2},
   189  				}, MaxTokens: nil, AuthorizationType: stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_UNDELEGATE,
   190  			},
   191  		},
   192  		{
   193  			"undelegate: fail cannot undelegate, permission denied",
   194  			[]sdk.ValAddress{},
   195  			[]sdk.ValAddress{val1},
   196  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_UNDELEGATE,
   197  			&coin100,
   198  			stakingtypes.NewMsgUndelegate(delAddr, val1, coin100),
   199  			true,
   200  			false,
   201  			nil,
   202  		},
   203  
   204  		{
   205  			"redelegate: expect 0 remaining coins",
   206  			[]sdk.ValAddress{val1, val2},
   207  			[]sdk.ValAddress{},
   208  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_REDELEGATE,
   209  			&coin100,
   210  			stakingtypes.NewMsgUndelegate(delAddr, val1, coin100),
   211  			false,
   212  			true,
   213  			nil,
   214  		},
   215  		{
   216  			"redelegate: verify remaining coins",
   217  			[]sdk.ValAddress{val1, val2},
   218  			[]sdk.ValAddress{},
   219  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_REDELEGATE,
   220  			&coin100,
   221  			stakingtypes.NewMsgBeginRedelegate(delAddr, val1, val1, coin50),
   222  			false,
   223  			false,
   224  			&stakingtypes.StakeAuthorization{
   225  				Validators: &stakingtypes.StakeAuthorization_AllowList{
   226  					AllowList: &stakingtypes.StakeAuthorization_Validators{Address: validators1_2},
   227  				}, MaxTokens: &coin50, AuthorizationType: stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_REDELEGATE,
   228  			},
   229  		},
   230  		{
   231  			"redelegate: testing with invalid validator",
   232  			[]sdk.ValAddress{val1, val2},
   233  			[]sdk.ValAddress{},
   234  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_REDELEGATE,
   235  			&coin100,
   236  			stakingtypes.NewMsgBeginRedelegate(delAddr, val3, val3, coin100),
   237  			true,
   238  			false,
   239  			nil,
   240  		},
   241  		{
   242  			"redelegate: testing delegate without spent limit",
   243  			[]sdk.ValAddress{val1, val2},
   244  			[]sdk.ValAddress{},
   245  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_REDELEGATE,
   246  			nil,
   247  			stakingtypes.NewMsgBeginRedelegate(delAddr, val2, val2, coin100),
   248  			false,
   249  			false,
   250  			&stakingtypes.StakeAuthorization{
   251  				Validators: &stakingtypes.StakeAuthorization_AllowList{
   252  					AllowList: &stakingtypes.StakeAuthorization_Validators{Address: validators1_2},
   253  				}, MaxTokens: nil, AuthorizationType: stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_REDELEGATE,
   254  			},
   255  		},
   256  		{
   257  			"redelegate: fail cannot undelegate, permission denied",
   258  			[]sdk.ValAddress{},
   259  			[]sdk.ValAddress{val1},
   260  			stakingtypes.AuthorizationType_AUTHORIZATION_TYPE_REDELEGATE,
   261  			&coin100,
   262  			stakingtypes.NewMsgBeginRedelegate(delAddr, val1, val1, coin100),
   263  			true,
   264  			false,
   265  			nil,
   266  		},
   267  	}
   268  
   269  	for _, tc := range testCases {
   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  }