1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
// Copyright (C) 2019-2023 Algorand, Inc.
// This file is part of go-algorand
//
// go-algorand 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.
//
// go-algorand 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 go-algorand. If not, see <https://www.gnu.org/licenses/>.
package verify
import (
"github.com/algorand/go-algorand/config"
"github.com/algorand/go-algorand/crypto/stateproof"
"github.com/algorand/go-algorand/data/basics"
"github.com/algorand/go-algorand/data/bookkeeping"
"github.com/algorand/go-algorand/data/stateproofmsg"
"github.com/algorand/go-algorand/ledger/ledgercore"
"github.com/algorand/go-algorand/logging"
"github.com/algorand/go-algorand/protocol"
"github.com/algorand/go-algorand/test/partitiontest"
"github.com/stretchr/testify/require"
"testing"
)
func invokeValidateStateProof(latestRoundInIntervalHdr *bookkeeping.BlockHeader,
stateProof *stateproof.StateProof,
votersHdr *bookkeeping.BlockHeader,
atRound basics.Round,
msg *stateproofmsg.Message) error {
verificationContext := ledgercore.StateProofVerificationContext{
LastAttestedRound: latestRoundInIntervalHdr.Round,
VotersCommitment: votersHdr.StateProofTracking[protocol.StateProofBasic].StateProofVotersCommitment,
OnlineTotalWeight: votersHdr.StateProofTracking[protocol.StateProofBasic].StateProofOnlineTotalWeight,
Version: votersHdr.CurrentProtocol,
}
return ValidateStateProof(&verificationContext, stateProof, atRound, msg)
}
func TestValidateStateProof(t *testing.T) {
partitiontest.PartitionTest(t)
spHdr := &bookkeeping.BlockHeader{}
sp := &stateproof.StateProof{}
votersHdr := &bookkeeping.BlockHeader{}
var atRound basics.Round
msg := &stateproofmsg.Message{BlockHeadersCommitment: []byte("this is an arbitrary message")}
// will definitely fail with nothing set up
err := invokeValidateStateProof(spHdr, sp, votersHdr, atRound, msg)
require.ErrorIs(t, err, errStateProofNotEnabled)
votersHdr.CurrentProtocol = "TestValidateStateProof"
proto := config.Consensus[spHdr.CurrentProtocol]
proto.StateProofInterval = 256
proto.StateProofStrengthTarget = 256
proto.StateProofWeightThreshold = (1 << 32) * 30 / 100
config.Consensus[votersHdr.CurrentProtocol] = proto
spHdr.Round = 1
err = invokeValidateStateProof(spHdr, sp, votersHdr, atRound, msg)
require.ErrorIs(t, err, errNotAtRightMultiple)
votersHdr.Round = 256
spHdr.Round = votersHdr.Round + basics.Round(proto.StateProofInterval)
sp.SignedWeight = 1
atRound = 800
err = invokeValidateStateProof(spHdr, sp, votersHdr, atRound, msg)
require.ErrorIs(t, err, stateproof.ErrIllegalInputForLnApprox)
votersHdr.StateProofTracking = make(map[protocol.StateProofType]bookkeeping.StateProofTrackingData)
cc := votersHdr.StateProofTracking[protocol.StateProofBasic]
cc.StateProofOnlineTotalWeight.Raw = 100
votersHdr.StateProofTracking[protocol.StateProofBasic] = cc
// Require 100% of the weight to be signed in order to accept stateproof before interval/2 rounds has passed from the latest round attested (optimal case)
sp.SignedWeight = 99 // suboptimal signed weight
atRound = votersHdr.Round + basics.Round(proto.StateProofInterval)
err = invokeValidateStateProof(spHdr, sp, votersHdr, atRound, msg)
require.ErrorIs(t, err, errInsufficientWeight)
atRound++
err = invokeValidateStateProof(spHdr, sp, votersHdr, atRound, msg)
require.ErrorIs(t, err, errInsufficientWeight)
// we don't pass the scaled weight
sp.SignedWeight = 96
latestRoundInProof := votersHdr.Round + basics.Round(proto.StateProofInterval)
atRound = latestRoundInProof + basics.Round(proto.StateProofInterval/2) + 5
err = invokeValidateStateProof(spHdr, sp, votersHdr, atRound, msg)
require.ErrorIs(t, err, errInsufficientWeight)
// we will pass the threshold since the network is now willing to take any state proof that has signedWeight over the threshold
sp.SignedWeight = 30
atRound = votersHdr.Round + 2*basics.Round(proto.StateProofInterval)
err = invokeValidateStateProof(spHdr, sp, votersHdr, atRound, msg)
require.ErrorIs(t, err, errStateProofCrypto)
// Above cases leave validateStateProof() with 100% coverage.
// crypto/stateproof.Verify has its own tests
}
func TestAcceptableStateProofWeight(t *testing.T) {
partitiontest.PartitionTest(t)
var votersHdr bookkeeping.BlockHeader
var firstValid basics.Round
logger := logging.TestingLog(t)
votersHdr.CurrentProtocol = "TestAcceptableStateProofWeight"
proto := config.Consensus[votersHdr.CurrentProtocol]
proto.StateProofInterval = 2
config.Consensus[votersHdr.CurrentProtocol] = proto
out := AcceptableStateProofWeight(&votersHdr, firstValid, logger)
require.Equal(t, uint64(0), out)
votersHdr.StateProofTracking = make(map[protocol.StateProofType]bookkeeping.StateProofTrackingData)
cc := votersHdr.StateProofTracking[protocol.StateProofBasic]
cc.StateProofOnlineTotalWeight.Raw = 100
votersHdr.StateProofTracking[protocol.StateProofBasic] = cc
out = AcceptableStateProofWeight(&votersHdr, firstValid, logger)
require.Equal(t, uint64(100), out)
// this should exercise the second return case
firstValid = basics.Round(3)
out = AcceptableStateProofWeight(&votersHdr, firstValid, logger)
require.Equal(t, uint64(100), out)
firstValid = basics.Round(6)
proto.StateProofWeightThreshold = 999999999
config.Consensus[votersHdr.CurrentProtocol] = proto
out = AcceptableStateProofWeight(&votersHdr, firstValid, logger)
require.Equal(t, uint64(0x17), out)
proto.StateProofInterval = 10000
votersHdr.Round = 10000
firstValid = basics.Round(29000 - 2)
config.Consensus[votersHdr.CurrentProtocol] = proto
cc.StateProofOnlineTotalWeight.Raw = 0x7fffffffffffffff
votersHdr.StateProofTracking[protocol.StateProofBasic] = cc
proto.StateProofWeightThreshold = 0x7fffffff
config.Consensus[votersHdr.CurrentProtocol] = proto
out = AcceptableStateProofWeight(&votersHdr, firstValid, logger)
require.Equal(t, uint64(0x4cd35a85213a92a2), out)
// Covers everything except "overflow that shouldn't happen" branches
}
func TestStateProofParams(t *testing.T) {
partitiontest.PartitionTest(t)
var votersHdr bookkeeping.BlockHeader
var hdr bookkeeping.BlockHeader
_, err := GetProvenWeight(&votersHdr, &hdr)
require.Error(t, err) // not enabled
votersHdr.CurrentProtocol = "TestStateProofParams"
proto := config.Consensus[votersHdr.CurrentProtocol]
proto.StateProofInterval = 2
config.Consensus[votersHdr.CurrentProtocol] = proto
votersHdr.Round = 1
_, err = GetProvenWeight(&votersHdr, &hdr)
require.Error(t, err) // wrong round
votersHdr.Round = 2
hdr.Round = 3
_, err = GetProvenWeight(&votersHdr, &hdr)
require.Error(t, err) // wrong round
// Covers all cases except overflow
}
|
