github.com/prysmaticlabs/prysm@v1.4.4/beacon-chain/powchain/deposit_test.go (about)

     1  package powchain
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"testing"
     7  
     8  	types "github.com/prysmaticlabs/eth2-types"
     9  	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
    10  	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
    11  	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
    12  	"github.com/prysmaticlabs/prysm/shared/bls"
    13  	"github.com/prysmaticlabs/prysm/shared/bytesutil"
    14  	"github.com/prysmaticlabs/prysm/shared/params"
    15  	"github.com/prysmaticlabs/prysm/shared/testutil"
    16  	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
    17  	"github.com/prysmaticlabs/prysm/shared/testutil/require"
    18  	"github.com/prysmaticlabs/prysm/shared/trieutil"
    19  	logTest "github.com/sirupsen/logrus/hooks/test"
    20  )
    21  
    22  const pubKeyErr = "could not convert bytes to public key"
    23  
    24  func TestProcessDeposit_OK(t *testing.T) {
    25  	beaconDB := testDB.SetupDB(t)
    26  	web3Service, err := NewService(context.Background(), &Web3ServiceConfig{
    27  		HttpEndpoints: []string{endpoint},
    28  		BeaconDB:      beaconDB,
    29  	})
    30  	require.NoError(t, err, "Unable to setup web3 ETH1.0 chain service")
    31  
    32  	web3Service = setDefaultMocks(web3Service)
    33  
    34  	deposits, _, err := testutil.DeterministicDepositsAndKeys(1)
    35  	require.NoError(t, err)
    36  
    37  	eth1Data, err := testutil.DeterministicEth1Data(len(deposits))
    38  	require.NoError(t, err)
    39  
    40  	err = web3Service.processDeposit(context.Background(), eth1Data, deposits[0])
    41  	require.NoError(t, err, "could not process deposit")
    42  
    43  	valcount, err := helpers.ActiveValidatorCount(web3Service.preGenesisState, 0)
    44  	require.NoError(t, err)
    45  	require.Equal(t, 1, int(valcount), "Did not get correct active validator count")
    46  }
    47  
    48  func TestProcessDeposit_InvalidMerkleBranch(t *testing.T) {
    49  	beaconDB := testDB.SetupDB(t)
    50  	web3Service, err := NewService(context.Background(), &Web3ServiceConfig{
    51  		HttpEndpoints: []string{endpoint},
    52  		BeaconDB:      beaconDB,
    53  	})
    54  	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
    55  	web3Service = setDefaultMocks(web3Service)
    56  
    57  	deposits, _, err := testutil.DeterministicDepositsAndKeys(1)
    58  	require.NoError(t, err)
    59  
    60  	eth1Data, err := testutil.DeterministicEth1Data(len(deposits))
    61  	require.NoError(t, err)
    62  
    63  	deposits[0].Proof = [][]byte{{'f', 'a', 'k', 'e'}}
    64  
    65  	err = web3Service.processDeposit(context.Background(), eth1Data, deposits[0])
    66  	require.NotNil(t, err, "No errors, when an error was expected")
    67  
    68  	want := "deposit merkle branch of deposit root did not verify for root"
    69  
    70  	assert.ErrorContains(t, want, err)
    71  }
    72  
    73  func TestProcessDeposit_InvalidPublicKey(t *testing.T) {
    74  	hook := logTest.NewGlobal()
    75  	beaconDB := testDB.SetupDB(t)
    76  	web3Service, err := NewService(context.Background(), &Web3ServiceConfig{
    77  		HttpEndpoints: []string{endpoint},
    78  		BeaconDB:      beaconDB,
    79  	})
    80  	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
    81  	web3Service = setDefaultMocks(web3Service)
    82  
    83  	deposits, _, err := testutil.DeterministicDepositsAndKeys(1)
    84  	require.NoError(t, err)
    85  	deposits[0].Data.PublicKey = bytesutil.PadTo([]byte("junk"), 48)
    86  
    87  	leaf, err := deposits[0].Data.HashTreeRoot()
    88  	require.NoError(t, err, "Could not hash deposit")
    89  
    90  	trie, err := trieutil.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth)
    91  	require.NoError(t, err)
    92  
    93  	deposits[0].Proof, err = trie.MerkleProof(0)
    94  	require.NoError(t, err)
    95  
    96  	root := trie.Root()
    97  
    98  	eth1Data := &ethpb.Eth1Data{
    99  		DepositCount: 1,
   100  		DepositRoot:  root[:],
   101  	}
   102  
   103  	err = web3Service.processDeposit(context.Background(), eth1Data, deposits[0])
   104  	require.NoError(t, err)
   105  
   106  	require.LogsContain(t, hook, pubKeyErr)
   107  }
   108  
   109  func TestProcessDeposit_InvalidSignature(t *testing.T) {
   110  	hook := logTest.NewGlobal()
   111  	beaconDB := testDB.SetupDB(t)
   112  	web3Service, err := NewService(context.Background(), &Web3ServiceConfig{
   113  		HttpEndpoints: []string{endpoint},
   114  		BeaconDB:      beaconDB,
   115  	})
   116  	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
   117  	web3Service = setDefaultMocks(web3Service)
   118  
   119  	deposits, _, err := testutil.DeterministicDepositsAndKeys(1)
   120  	require.NoError(t, err)
   121  	var fakeSig [96]byte
   122  	copy(fakeSig[:], []byte{'F', 'A', 'K', 'E'})
   123  	deposits[0].Data.Signature = fakeSig[:]
   124  
   125  	leaf, err := deposits[0].Data.HashTreeRoot()
   126  	require.NoError(t, err, "Could not hash deposit")
   127  
   128  	trie, err := trieutil.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth)
   129  	require.NoError(t, err)
   130  
   131  	root := trie.Root()
   132  
   133  	eth1Data := &ethpb.Eth1Data{
   134  		DepositCount: 1,
   135  		DepositRoot:  root[:],
   136  	}
   137  
   138  	err = web3Service.processDeposit(context.Background(), eth1Data, deposits[0])
   139  	require.NoError(t, err)
   140  
   141  	require.LogsContain(t, hook, "could not verify deposit data signature: could not convert bytes to signature")
   142  }
   143  
   144  func TestProcessDeposit_UnableToVerify(t *testing.T) {
   145  	hook := logTest.NewGlobal()
   146  	beaconDB := testDB.SetupDB(t)
   147  	web3Service, err := NewService(context.Background(), &Web3ServiceConfig{
   148  		HttpEndpoints: []string{endpoint},
   149  		BeaconDB:      beaconDB,
   150  	})
   151  	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
   152  	web3Service = setDefaultMocks(web3Service)
   153  
   154  	deposits, keys, err := testutil.DeterministicDepositsAndKeys(1)
   155  	require.NoError(t, err)
   156  	sig := keys[0].Sign([]byte{'F', 'A', 'K', 'E'})
   157  	deposits[0].Data.Signature = sig.Marshal()
   158  
   159  	trie, _, err := testutil.DepositTrieFromDeposits(deposits)
   160  	require.NoError(t, err)
   161  	root := trie.Root()
   162  	eth1Data := &ethpb.Eth1Data{
   163  		DepositCount: 1,
   164  		DepositRoot:  root[:],
   165  	}
   166  	proof, err := trie.MerkleProof(0)
   167  	require.NoError(t, err)
   168  	deposits[0].Proof = proof
   169  	err = web3Service.processDeposit(context.Background(), eth1Data, deposits[0])
   170  	require.NoError(t, err)
   171  	want := "signature did not verify"
   172  
   173  	require.LogsContain(t, hook, want)
   174  
   175  }
   176  
   177  func TestProcessDeposit_IncompleteDeposit(t *testing.T) {
   178  	beaconDB := testDB.SetupDB(t)
   179  	web3Service, err := NewService(context.Background(), &Web3ServiceConfig{
   180  		HttpEndpoints: []string{endpoint},
   181  		BeaconDB:      beaconDB,
   182  	})
   183  	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
   184  	web3Service = setDefaultMocks(web3Service)
   185  	require.NoError(t, web3Service.preGenesisState.SetValidators([]*ethpb.Validator{}))
   186  
   187  	deposit := &ethpb.Deposit{
   188  		Data: &ethpb.Deposit_Data{
   189  			Amount:                params.BeaconConfig().EffectiveBalanceIncrement, // incomplete deposit
   190  			WithdrawalCredentials: bytesutil.PadTo([]byte("testing"), 32),
   191  			Signature:             bytesutil.PadTo([]byte("test"), 96),
   192  		},
   193  	}
   194  
   195  	priv, err := bls.RandKey()
   196  	require.NoError(t, err)
   197  	deposit.Data.PublicKey = priv.PublicKey().Marshal()
   198  	d, err := helpers.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
   199  	require.NoError(t, err)
   200  	signedRoot, err := helpers.ComputeSigningRoot(deposit.Data, d)
   201  	require.NoError(t, err)
   202  
   203  	sig := priv.Sign(signedRoot[:])
   204  	deposit.Data.Signature = sig.Marshal()
   205  
   206  	trie, err := trieutil.NewTrie(params.BeaconConfig().DepositContractTreeDepth)
   207  	require.NoError(t, err)
   208  	root := trie.Root()
   209  	eth1Data := &ethpb.Eth1Data{
   210  		DepositCount: 1,
   211  		DepositRoot:  root[:],
   212  	}
   213  	proof, err := trie.MerkleProof(0)
   214  	require.NoError(t, err)
   215  	dataRoot, err := deposit.Data.HashTreeRoot()
   216  	require.NoError(t, err)
   217  	deposit.Proof = proof
   218  
   219  	factor := params.BeaconConfig().MaxEffectiveBalance / params.BeaconConfig().EffectiveBalanceIncrement
   220  	// deposit till 31e9
   221  	for i := 0; i < int(factor-1); i++ {
   222  		trie.Insert(dataRoot[:], i)
   223  
   224  		trieRoot := trie.HashTreeRoot()
   225  		eth1Data.DepositRoot = trieRoot[:]
   226  		eth1Data.DepositCount = uint64(i + 1)
   227  
   228  		deposit.Proof, err = trie.MerkleProof(i)
   229  		require.NoError(t, err)
   230  		err = web3Service.processDeposit(context.Background(), eth1Data, deposit)
   231  		require.NoError(t, err, fmt.Sprintf("Could not process deposit at %d", i))
   232  
   233  		valcount, err := helpers.ActiveValidatorCount(web3Service.preGenesisState, 0)
   234  		require.NoError(t, err)
   235  		require.Equal(t, 0, int(valcount), "Did not get correct active validator count")
   236  	}
   237  }
   238  
   239  func TestProcessDeposit_AllDepositedSuccessfully(t *testing.T) {
   240  	beaconDB := testDB.SetupDB(t)
   241  	web3Service, err := NewService(context.Background(), &Web3ServiceConfig{
   242  		HttpEndpoints: []string{endpoint},
   243  		BeaconDB:      beaconDB,
   244  	})
   245  	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
   246  	web3Service = setDefaultMocks(web3Service)
   247  
   248  	deposits, keys, err := testutil.DeterministicDepositsAndKeys(10)
   249  	require.NoError(t, err)
   250  	eth1Data, err := testutil.DeterministicEth1Data(len(deposits))
   251  	require.NoError(t, err)
   252  
   253  	for i := range keys {
   254  		eth1Data.DepositCount = uint64(i + 1)
   255  		err = web3Service.processDeposit(context.Background(), eth1Data, deposits[i])
   256  		require.NoError(t, err, fmt.Sprintf("Could not process deposit at %d", i))
   257  
   258  		valCount, err := helpers.ActiveValidatorCount(web3Service.preGenesisState, 0)
   259  		require.NoError(t, err)
   260  		require.Equal(t, uint64(i+1), valCount, "Did not get correct active validator count")
   261  
   262  		val, err := web3Service.preGenesisState.ValidatorAtIndex(types.ValidatorIndex(i))
   263  		require.NoError(t, err)
   264  		assert.Equal(t, params.BeaconConfig().MaxEffectiveBalance, val.EffectiveBalance)
   265  	}
   266  }