code.vegaprotocol.io/vega@v0.79.0/wallet/api/spam/spam_test.go

// Copyright (C) 2023 Gobalsky Labs Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package spam_test

import (
	"testing"

	vgcrypto "code.vegaprotocol.io/vega/libs/crypto"
	"code.vegaprotocol.io/vega/libs/ptr"
	v1 "code.vegaprotocol.io/vega/protos/vega/commands/v1"
	walletpb "code.vegaprotocol.io/vega/protos/vega/wallet/v1"
	nodetypes "code.vegaprotocol.io/vega/wallet/api/node/types"
	"code.vegaprotocol.io/vega/wallet/api/spam"

	"github.com/stretchr/testify/require"
)

var (
	policies = []string{
		"proposals",
		"delegations",
		"announcements",
		"transfers",
		"votes",
		"issueSignatures",
	}
	proposalID = "default-proposal-id"
)

func TestSpamAwareness(t *testing.T) {
	t.Run("spam policy has been banned", testSpamPolicyBannedUtil)
	t.Run("spam policy will get banned", testSpamPolicyWillGetBanned)
	t.Run("spam policy hits limit", testSpamPolicyHitsLimit)
	t.Run("spam policy new epoch", testSpamPolicyNewEpoch)
	t.Run("spam policy pow ban", testSpamPolicyPoWBan)
	t.Run("spam policy votes separate proposals", testSpamVotesSeparateProposals)
	t.Run("other transaction types not blocked", testOtherTransactionTypesNotBlock)
}

func testSpamPolicyBannedUtil(t *testing.T) {
	p := spam.NewHandler()

	pubKey := vgcrypto.RandomHash()
	banned := nodetypes.SpamStatistic{
		BannedUntil:   ptr.From("forever"),
		MaxForEpoch:   100,
		CountForEpoch: 100,
	}

	for _, f := range policies {
		s, req := getSimplePolicyStats(t, pubKey, f, banned)
		err := p.CheckSubmission(req, s)
		require.Equal(t, err.Error(), "party is banned from submitting transactions of this type until forever")
	}
}

func testSpamPolicyWillGetBanned(t *testing.T) {
	p := spam.NewHandler()

	pubKey := vgcrypto.RandomHash()
	willBan := nodetypes.SpamStatistic{
		BannedUntil:   nil,
		MaxForEpoch:   100,
		CountForEpoch: 100,
	}

	for _, f := range policies {
		s, req := getSimplePolicyStats(t, pubKey, f, willBan)
		err := p.CheckSubmission(req, s)
		require.Equal(t, err.Error(), "party has already submitted the maximum number of transactions of this type per epoch (100)")
	}
}

func testSpamPolicyHitsLimit(t *testing.T) {
	p := spam.NewHandler()
	pubKey := vgcrypto.RandomHash()
	stat := nodetypes.SpamStatistic{
		BannedUntil:   nil,
		MaxForEpoch:   100,
		CountForEpoch: 99,
	}

	for _, f := range policies {
		s, req := getSimplePolicyStats(t, pubKey, f, stat)

		// we are at 99 and this check pushes to 100
		err := p.CheckSubmission(req, s)
		require.NoError(t, err)

		// so the next one will fail
		err = p.CheckSubmission(req, s)
		require.Error(t, err, spam.ErrPartyWillBeBanned)
	}
}

func testSpamPolicyNewEpoch(t *testing.T) {
	p := spam.NewHandler()
	pubKey := vgcrypto.RandomHash()
	for i, f := range policies {
		stat := nodetypes.SpamStatistic{
			BannedUntil:   nil,
			MaxForEpoch:   100,
			CountForEpoch: 88,
		}
		s, req := getSimplePolicyStats(t, pubKey, f, stat)

		// we are at 88 and this check pushes to 100
		err := p.CheckSubmission(req, s)
		require.NoError(t, err)

		// spam update is more than our count so we trust it
		stat.CountForEpoch = 100
		s, req = getSimplePolicyStats(t, pubKey, f, stat)
		err = p.CheckSubmission(req, s)
		require.Error(t, err, spam.ErrPartyWillBeBanned)

		// dip into a new epoch so we take the spam stats lower value
		stat.CountForEpoch = 0
		s, req = getSimplePolicyStats(t, pubKey, f, stat)
		s.EpochSeq += (1 + uint64(i))
		err = p.CheckSubmission(req, s)
		require.NoError(t, err)
	}
}

func testSpamPolicyPoWBan(t *testing.T) {
	p := spam.NewHandler()
	pubKey := vgcrypto.RandomHash()
	for _, f := range policies {
		stat := nodetypes.SpamStatistic{
			BannedUntil:   nil,
			MaxForEpoch:   100,
			CountForEpoch: 88,
		}
		s, req := getSimplePolicyStats(t, pubKey, f, stat)
		s.PoW.BannedUntil = ptr.From("forever")

		// we are at 88 so find to submit, but banned by PoW
		err := p.CheckSubmission(req, s)
		require.Equal(t, err.Error(), "party is banned from submitting all transactions until forever")
	}
}

func testSpamVotesSeparateProposals(t *testing.T) {
	p := spam.NewHandler()
	pubKey := vgcrypto.RandomHash()

	stat := nodetypes.SpamStatistic{
		BannedUntil:   nil,
		MaxForEpoch:   100,
		CountForEpoch: 100,
	}
	s, req := getSimplePolicyStats(t, pubKey, "votes", stat)

	// we're at our max for the first proposal
	err := p.CheckSubmission(req, s)
	require.Equal(t, err.Error(), "party has already submitted the maximum number of transactions of this type per epoch (100)")

	// but can still submit against a different proposal
	req = &walletpb.SubmitTransactionRequest{
		PubKey: pubKey,
		Command: &walletpb.SubmitTransactionRequest_VoteSubmission{
			VoteSubmission: &v1.VoteSubmission{
				ProposalId: vgcrypto.RandomHash(),
			},
		},
	}
	err = p.CheckSubmission(req, s)
	require.NoError(t, err)
}

func testOtherTransactionTypesNotBlock(t *testing.T) {
	p := spam.NewHandler()
	pubKey := vgcrypto.RandomHash()
	until := ptr.From("forever")

	stat := nodetypes.SpamStatistic{
		BannedUntil: until,
	}

	// banned on everything except for proof-of-work
	stats := &nodetypes.SpamStatistics{
		PoW:               &nodetypes.PoWStatistics{},
		Proposals:         &stat,
		Delegations:       &stat,
		Transfers:         &stat,
		NodeAnnouncements: &stat,
		IssuesSignatures:  &stat,
		Votes: &nodetypes.VoteSpamStatistics{
			BannedUntil: until,
		},
	}

	// but can still submit against a different proposal
	req := &walletpb.SubmitTransactionRequest{
		PubKey:  pubKey,
		Command: &walletpb.SubmitTransactionRequest_OrderSubmission{},
	}
	err := p.CheckSubmission(req, stats)
	require.NoError(t, err)

	// but pow ban still applies
	stats.PoW.BannedUntil = until
	err = p.CheckSubmission(req, stats)
	require.Equal(t, err.Error(), "party is banned from submitting all transactions until forever")
}

func getSimplePolicyStats(t *testing.T, pubKey, policy string, st nodetypes.SpamStatistic) (*nodetypes.SpamStatistics, *walletpb.SubmitTransactionRequest) {
	t.Helper()
	spam := defaultSpamStats(t)
	req := &walletpb.SubmitTransactionRequest{
		PubKey: pubKey,
	}

	switch policy {
	case "proposals":
		spam.Proposals = &st
		req.Command = &walletpb.SubmitTransactionRequest_ProposalSubmission{}
	case "delegations":
		spam.Delegations = &st
		req.Command = &walletpb.SubmitTransactionRequest_DelegateSubmission{}
	case "transfers":
		spam.Transfers = &st
		req.Command = &walletpb.SubmitTransactionRequest_Transfer{}
	case "announcements":
		spam.NodeAnnouncements = &st
		req.Command = &walletpb.SubmitTransactionRequest_AnnounceNode{}
	case "issueSignatures":
		spam.IssuesSignatures = &st
		req.Command = &walletpb.SubmitTransactionRequest_IssueSignatures{}
	case "votes":
		spam.Votes.MaxForEpoch = st.MaxForEpoch
		spam.Votes.BannedUntil = st.BannedUntil
		spam.Votes.Proposals = map[string]uint64{proposalID: st.CountForEpoch}
		req.Command = &walletpb.SubmitTransactionRequest_VoteSubmission{
			VoteSubmission: &v1.VoteSubmission{
				ProposalId: proposalID,
			},
		}
	default:
		t.FailNow()
	}

	return spam, req
}