code.vegaprotocol.io/vega@v0.79.0/core/staking/stake_verifier_snapshot_test.go (about)

     1  // Copyright (C) 2023 Gobalsky Labs Limited
     2  //
     3  // This program is free software: you can redistribute it and/or modify
     4  // it under the terms of the GNU Affero General Public License as
     5  // published by the Free Software Foundation, either version 3 of the
     6  // License, or (at your option) any later version.
     7  //
     8  // This program is distributed in the hope that it will be useful,
     9  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    10  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    11  // GNU Affero General Public License for more details.
    12  //
    13  // You should have received a copy of the GNU Affero General Public License
    14  // along with this program.  If not, see <http://www.gnu.org/licenses/>.
    15  
    16  package staking_test
    17  
    18  import (
    19  	"bytes"
    20  	"context"
    21  	"testing"
    22  
    23  	"code.vegaprotocol.io/vega/core/staking"
    24  	"code.vegaprotocol.io/vega/core/types"
    25  	"code.vegaprotocol.io/vega/libs/num"
    26  	"code.vegaprotocol.io/vega/libs/proto"
    27  	snapshot "code.vegaprotocol.io/vega/protos/vega/snapshot/v1"
    28  
    29  	"github.com/golang/mock/gomock"
    30  	"github.com/stretchr/testify/assert"
    31  	"github.com/stretchr/testify/require"
    32  )
    33  
    34  var (
    35  	depositedKey = (&types.PayloadStakeVerifierDeposited{}).Key()
    36  	removedKey   = (&types.PayloadStakeVerifierRemoved{}).Key()
    37  )
    38  
    39  func TestSVSnapshotEmpty(t *testing.T) {
    40  	sv := getStakeVerifierTest(t)
    41  	defer sv.ctrl.Finish()
    42  
    43  	assert.Equal(t, 2, len(sv.Keys()))
    44  
    45  	s, _, err := sv.GetState(depositedKey)
    46  	require.Nil(t, err)
    47  	require.NotNil(t, s)
    48  
    49  	s, _, err = sv.GetState(removedKey)
    50  	require.Nil(t, err)
    51  	require.NotNil(t, s)
    52  }
    53  
    54  func TestSVSnapshotDeposited(t *testing.T) {
    55  	key := depositedKey
    56  	ctx := context.Background()
    57  	sv := getStakeVerifierTest(t)
    58  	defer sv.ctrl.Finish()
    59  
    60  	sv.tsvc.EXPECT().GetTimeNow().Times(1)
    61  	sv.broker.EXPECT().Send(gomock.Any()).Times(1)
    62  	sv.witness.EXPECT().StartCheck(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
    63  
    64  	s1, _, err := sv.GetState(key)
    65  	require.Nil(t, err)
    66  	require.NotNil(t, s1)
    67  
    68  	event := &types.StakeDeposited{
    69  		BlockNumber:     42,
    70  		LogIndex:        1789,
    71  		TxID:            "somehash",
    72  		ID:              "someid",
    73  		VegaPubKey:      "somepubkey",
    74  		EthereumAddress: "0xnothex",
    75  		Amount:          num.NewUint(1000),
    76  		BlockTime:       100000,
    77  	}
    78  
    79  	err = sv.ProcessStakeDeposited(ctx, event)
    80  	require.Nil(t, err)
    81  
    82  	s2, _, err := sv.GetState(key)
    83  	require.Nil(t, err)
    84  	require.False(t, bytes.Equal(s1, s2))
    85  
    86  	state, _, err := sv.GetState(key)
    87  	require.Nil(t, err)
    88  
    89  	snap := &snapshot.Payload{}
    90  	err = proto.Unmarshal(state, snap)
    91  	require.Nil(t, err)
    92  
    93  	// Restore into new things
    94  	snapSV := getStakeVerifierTest(t)
    95  	defer snapSV.ctrl.Finish()
    96  	snapSV.witness.EXPECT().RestoreResource(gomock.Any(), gomock.Any()).Times(1)
    97  
    98  	snapSV.broker.EXPECT().SendBatch(gomock.Any()).Times(1)
    99  	_, err = snapSV.LoadState(ctx, types.PayloadFromProto(snap))
   100  	require.Nil(t, err)
   101  	// Check its there by adding it again and checking for duplication error
   102  	require.ErrorIs(t, staking.ErrDuplicatedStakeDepositedEvent, snapSV.ProcessStakeDeposited(ctx, event))
   103  }
   104  
   105  func TestSVSnapshotRemoved(t *testing.T) {
   106  	key := removedKey
   107  	ctx := context.Background()
   108  	sv := getStakeVerifierTest(t)
   109  	defer sv.ctrl.Finish()
   110  
   111  	sv.tsvc.EXPECT().GetTimeNow().Times(1)
   112  	sv.broker.EXPECT().Send(gomock.Any()).Times(1)
   113  	sv.witness.EXPECT().StartCheck(gomock.Any(), gomock.Any(), gomock.Any()).Times(1)
   114  
   115  	s1, _, err := sv.GetState(key)
   116  	require.Nil(t, err)
   117  	require.NotNil(t, s1)
   118  
   119  	event := &types.StakeRemoved{
   120  		BlockNumber:     42,
   121  		LogIndex:        1789,
   122  		TxID:            "somehash",
   123  		ID:              "someid",
   124  		VegaPubKey:      "somepubkey",
   125  		EthereumAddress: "0xnothex",
   126  		Amount:          num.NewUint(1000),
   127  		BlockTime:       100000,
   128  	}
   129  
   130  	err = sv.ProcessStakeRemoved(ctx, event)
   131  	require.Nil(t, err)
   132  
   133  	s2, _, err := sv.GetState(key)
   134  	require.Nil(t, err)
   135  	require.False(t, bytes.Equal(s1, s2))
   136  
   137  	state, _, err := sv.GetState(key)
   138  	require.Nil(t, err)
   139  
   140  	snap := &snapshot.Payload{}
   141  	err = proto.Unmarshal(state, snap)
   142  	require.Nil(t, err)
   143  
   144  	// Restore into new things
   145  	snapSV := getStakeVerifierTest(t)
   146  	defer snapSV.ctrl.Finish()
   147  	snapSV.witness.EXPECT().RestoreResource(gomock.Any(), gomock.Any()).Times(1)
   148  
   149  	snapSV.broker.EXPECT().SendBatch(gomock.Any()).Times(1)
   150  	_, err = snapSV.LoadState(ctx, types.PayloadFromProto(snap))
   151  	require.Nil(t, err)
   152  	// Check its there by adding it again and checking for duplication error
   153  	require.ErrorIs(t, staking.ErrDuplicatedStakeRemovedEvent, snapSV.ProcessStakeRemoved(ctx, event))
   154  }