You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
556 lines
19 KiB
556 lines
19 KiB
package slash
|
|
|
|
import (
|
|
"encoding/hex"
|
|
"fmt"
|
|
"math/big"
|
|
"testing"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/ethdb"
|
|
"github.com/ethereum/go-ethereum/rlp"
|
|
"github.com/harmony-one/bls/ffi/go/bls"
|
|
"github.com/harmony-one/harmony/block"
|
|
"github.com/harmony-one/harmony/common/denominations"
|
|
"github.com/harmony-one/harmony/consensus/votepower"
|
|
"github.com/harmony-one/harmony/core/state"
|
|
"github.com/harmony-one/harmony/core/types"
|
|
common2 "github.com/harmony-one/harmony/internal/common"
|
|
"github.com/harmony-one/harmony/internal/params"
|
|
"github.com/harmony-one/harmony/numeric"
|
|
"github.com/harmony-one/harmony/shard"
|
|
"github.com/harmony-one/harmony/staking/effective"
|
|
staking "github.com/harmony-one/harmony/staking/types"
|
|
)
|
|
|
|
var (
|
|
commonCommission = staking.Commission{
|
|
CommissionRates: staking.CommissionRates{
|
|
Rate: numeric.MustNewDecFromStr("0.167983520183826780"),
|
|
MaxRate: numeric.MustNewDecFromStr("0.179184469782137200"),
|
|
MaxChangeRate: numeric.MustNewDecFromStr("0.152212761523253600"),
|
|
},
|
|
UpdateHeight: big.NewInt(10),
|
|
}
|
|
|
|
commonDescr = staking.Description{
|
|
Name: "someoneA",
|
|
Identity: "someoneB",
|
|
Website: "someoneC",
|
|
SecurityContact: "someoneD",
|
|
Details: "someoneE",
|
|
}
|
|
|
|
fiveKOnes = new(big.Int).Mul(big.NewInt(5000), big.NewInt(1e18))
|
|
tenKOnes = new(big.Int).Mul(big.NewInt(10000), big.NewInt(1e18))
|
|
onePointNineSixKOnes = new(big.Int).Mul(big.NewInt(19600), big.NewInt(1e18))
|
|
twentyKOnes = new(big.Int).Mul(big.NewInt(20000), big.NewInt(1e18))
|
|
twentyfiveKOnes = new(big.Int).Mul(big.NewInt(25000), big.NewInt(1e18))
|
|
thirtyKOnes = new(big.Int).Mul(big.NewInt(30000), big.NewInt(1e18))
|
|
hundredKOnes = new(big.Int).Mul(big.NewInt(1000000), big.NewInt(1e18))
|
|
)
|
|
|
|
const (
|
|
// ballot A hex values
|
|
signerABLSPublicHex = "be23bc3c93fe14a25f3533" +
|
|
"feee1cff1c60706845a4907" +
|
|
"c5df58bc19f5d1760bfff06fe7c9d1f596b18fdf529e0508e0a"
|
|
signerAHeaderHashHex = "0x68bf572c03e36b4b7a4f268797d18" +
|
|
"7027b288bc69725084bab5bfe6214cb8ddf"
|
|
signerABLSSignature = "ab14e519485b70d8af76ae83205" +
|
|
"290792d679a8a11eb9a12d21787cc0b73" +
|
|
"96e340d88b2a0c39888d0c9cec1" +
|
|
"2c4a09b06b2eec3e851f08f3070f3" +
|
|
"804b35fe4a2033725f073623e3870756141ebc" +
|
|
"2a6495478930c428f6e6b25f292dab8552d30c"
|
|
// ballot B hex values
|
|
signerBBLSPublicHex = "be23bc3c93fe14a25f3533" +
|
|
"feee1cff1c60706845a490" +
|
|
"7c5df58bc19f5d1760bfff" +
|
|
"06fe7c9d1f596b18fdf529e0508e0a"
|
|
signerBHeaderHashHex = "0x1dbf572c03e36b4b7a4f268797d187" +
|
|
"027b288bc69725084bab5bfe6214cb8ddf"
|
|
signerBBLSSignature = "0894d55a541a90ada11535866e5a848d9d6a2b5c30" +
|
|
"932a95f48133f886140cefbe4d690eddd0540d246df1fec" +
|
|
"8b4f719ad9de0bc822f0a1bf70e78b321a5e4462ba3e3efd" +
|
|
"cd24c21b9cb24ed6b26f02785a2cdbd168696c5f4a49b6c00f00994"
|
|
// RLP encoded header
|
|
proposalHeaderRLPBytes = "f9039187486d6e79546764827633f90383a080532768867d8c1a96" +
|
|
"6ae9df80d4efc9a9a83559b0e2d13b2aa819a6a7627c7294" +
|
|
"6911b75b2560be9a8f71164a33086be4511fc99aa0eb514ec3bc1" +
|
|
"8e67ad7d9641768b7a9b9655ff78e54970465aeb037c2d81c5987a05" +
|
|
"6e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc0016" +
|
|
"22fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b" +
|
|
"48e01b996cadc001622fb5e363b421a056e81f171bcc55a6" +
|
|
"ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a05" +
|
|
"6e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc0" +
|
|
"01622fb5e363b421b901000000000000000000000000000" +
|
|
"00000000000000000000000000000000000000000000000000" +
|
|
"00000000000000000000000000000000000000000000000000000" +
|
|
"000000000000000000000000000000000000000000000000000000" +
|
|
"00000000000000000000000000000000000000000000000000000000" +
|
|
"000000000000000000000000000000000000000000000000000000000" +
|
|
"0000000000000000000000000000000000000000000000000000000" +
|
|
"0000000000000000000000000000000000000000000000000000" +
|
|
"00000000000000000000000000000000000000000000000000000" +
|
|
"00000000000000000000000000000000000000000000000000000" +
|
|
"00002383a9235180845e4c602680a00000000000000000000000" +
|
|
"000000000000000000000000000000000000000000230680b860c" +
|
|
"4db93981d5870f0f77bb8487dde189e4579e3866ae3b598fbed0f5" +
|
|
"d87e53d21a039e427d2a206eeca4ff1f1fab2ed0d2171b9c1f12" +
|
|
"1e42c1a1456e6e1ba4c5e2fb3ddda5d34873bcdf01f14d1da1bc5" +
|
|
"0e70dc6f0bdfda3f36f9dafe1e29880e7fb8807b05ee6062476f5a43" +
|
|
"6b29876d726491fb76bfe2cf8f6d9e3a7361e0ca95bd66c4ef4593c" +
|
|
"2ac616c4ca171af74a93f5ef9e4d1b74421e789f07e0a36e4b00b7a9" +
|
|
"13fb6a296e20ee4dcd2d74088ea9711b8b7693af18d3f6ab925d26a0b" +
|
|
"e30d8899f18e4b7f9e8c6937e78863b828fa172e8edef106cca814294" +
|
|
"eee7146eec7018080b88bf889f887a0a1cc8366aa9c8acac219a229b2" +
|
|
"eb88deee3bc9b133baa610bd88af294422ab0020b860e5a234c8bce79" +
|
|
"24c4f934edf7ce9f8f4b10d61d1e72becdda95c5fb3195598cc9ae334" +
|
|
"8a00c493fb77a87a094dbf08130c3f93793337be78167b8b241d7ef9e" +
|
|
"1fab1f8097dda339a6ca2737c291d8a7733c9b5b540ea30544c46" +
|
|
"a0426a34f60d3f010580"
|
|
// trailing bech32 info
|
|
reporterBech32 = "one1pdv9lrdwl0rg5vglh4xtyrv3wjk3wsqket7zxy"
|
|
offenderBech32 = "one1zyxauxquys60dk824p532jjdq753pnsenrgmef"
|
|
// some rando delegator
|
|
randoDelegatorBech32 = "one1nqevvacj3y5ltuef05my4scwy5wuqteur72jk5"
|
|
// rest of the committee
|
|
commK1 = "65f55eb3052f9e9f632b2923be594ba77c55543f5c58ee1454b9cfd658d25e06373b0f7d42a19c84768139ea294f6204"
|
|
commK2 = "02c8ff0b88f313717bc3a627d2f8bb172ba3ad3bb9ba3ecb8eed4b7c878653d3d4faf769876c528b73f343967f74a917"
|
|
commK3 = "e751ec995defe4931273aaebcb2cd14bf37e629c554a57d3f334c37881a34a6188a93e76113c55ef3481da23b7d7ab09"
|
|
commK4 = "2d61379e44a772e5757e27ee2b3874254f56073e6bd226eb8b160371cc3c18b8c4977bd3dcb71fd57dc62bf0e143fd08"
|
|
commK5 = "86dc2fdc2ceec18f6923b99fd86a68405c132e1005cf1df72dca75db0adfaeb53d201d66af37916d61f079f34f21fb96"
|
|
commK6 = "95117937cd8c09acd2dfae847d74041a67834ea88662a7cbed1e170350bc329e53db151e5a0ef3e712e35287ae954818"
|
|
// double signing info
|
|
doubleSignShardID = 0
|
|
doubleSignEpoch = 3
|
|
doubleSignBlockNumber = 37
|
|
doubleSignViewID = 38
|
|
doubleSignUnixNano = 1582049233802498300
|
|
// validator creation parameters
|
|
lastEpochInComm = 5
|
|
creationHeight = 33
|
|
// slash rates to test double signing
|
|
// from 0 percent to 100 percent slash rate, 1 percent increment per testSlashRate
|
|
numSlashRatesToTest = 101
|
|
)
|
|
|
|
type scenario struct {
|
|
snapshot, current *staking.ValidatorWrapper
|
|
slashRate float64
|
|
result *Application
|
|
}
|
|
|
|
func defaultFundingScenario() *scenario {
|
|
return &scenario{
|
|
snapshot: nil,
|
|
current: nil,
|
|
slashRate: 0.02,
|
|
result: nil,
|
|
}
|
|
}
|
|
|
|
var (
|
|
scenarioTwoPercent = defaultFundingScenario()
|
|
scenarioEightyPercent = defaultFundingScenario()
|
|
doubleSignScenarios = make([]*scenario, numSlashRatesToTest)
|
|
)
|
|
|
|
func totalSlashedExpected(slashRate float64) *big.Int {
|
|
t := int64(50000 * slashRate)
|
|
res := new(big.Int).Mul(big.NewInt(t), big.NewInt(denominations.One))
|
|
return res
|
|
//return big.NewInt(int64(slashRate * 50000 * denominations.One)) // 5.0 * denominations.One
|
|
}
|
|
|
|
func totalSnitchRewardExpected(slashRate float64) *big.Int {
|
|
t := int64(25000 * slashRate)
|
|
res := new(big.Int).Mul(big.NewInt(t), big.NewInt(denominations.One))
|
|
return res
|
|
//return big.NewInt(int64(slashRate * 2.5 * denominations.One))
|
|
}
|
|
|
|
func init() {
|
|
{
|
|
s := scenarioTwoPercent
|
|
s.slashRate = 0.02
|
|
s.result = &Application{
|
|
// totalSlashedExpected
|
|
TotalSlashed: totalSlashedExpected(s.slashRate), // big.NewInt(int64(s.slashRate * 5.0 * denominations.One)),
|
|
// totalSnitchRewardExpected
|
|
TotalSnitchReward: totalSnitchRewardExpected(s.slashRate), // big.NewInt(int64(s.slashRate * 2.5 * denominations.One)),
|
|
}
|
|
s.snapshot, s.current = s.defaultValidatorPair(s.defaultDelegationPair())
|
|
}
|
|
{
|
|
s := scenarioEightyPercent
|
|
s.slashRate = 0.80
|
|
s.result = &Application{
|
|
// totalSlashedExpected
|
|
TotalSlashed: totalSlashedExpected(s.slashRate), // big.NewInt(int64(s.slashRate * 5.0 * denominations.One)),
|
|
// totalSnitchRewardExpected
|
|
TotalSnitchReward: totalSnitchRewardExpected(s.slashRate), // big.NewInt(int64(s.slashRate * 2.5 * denominations.One)),
|
|
}
|
|
s.snapshot, s.current = s.defaultValidatorPair(s.defaultDelegationPair())
|
|
}
|
|
|
|
// Testing slash rate from 0% to 100% with increment being 100.0 / numSlashRatesToTest.
|
|
// numSlashRatesToTest=100, so it's 1 percent step size in between test slash rates.
|
|
testSlashRateStepSize := numeric.NewDec(1).
|
|
Quo(numeric.NewDec(numSlashRatesToTest - 1)) // -1 since starting from 0% slash rate edge case
|
|
slashRate := numeric.NewDec(0)
|
|
for i := 0; i < numSlashRatesToTest; i++ {
|
|
s := defaultFundingScenario()
|
|
s.slashRate = float64(slashRate.Quo(numeric.NewDec(100)).TruncateInt64())
|
|
s.result = &Application{
|
|
TotalSlashed: totalSlashedExpected(s.slashRate),
|
|
TotalSnitchReward: totalSnitchRewardExpected(s.slashRate),
|
|
}
|
|
s.snapshot, s.current = s.defaultValidatorPair(s.defaultDelegationPair())
|
|
doubleSignScenarios[i] = s
|
|
|
|
slashRate = slashRate.Add(testSlashRateStepSize)
|
|
}
|
|
}
|
|
|
|
var (
|
|
signerA, signerB = &bls.PublicKey{}, &bls.PublicKey{}
|
|
hashA, hashB = common.Hash{}, common.Hash{}
|
|
reporterAddr, offenderAddr = common.Address{}, common.Address{}
|
|
randoDel = common.Address{}
|
|
header = block.Header{}
|
|
subCommittee = []shard.BLSPublicKey{}
|
|
doubleSignEpochBig = big.NewInt(doubleSignEpoch)
|
|
|
|
unit = func() interface{} {
|
|
// Ballot A setup
|
|
signerA.DeserializeHexStr(signerABLSPublicHex)
|
|
headerHashA, _ := hex.DecodeString(signerAHeaderHashHex)
|
|
hashA = common.BytesToHash(headerHashA)
|
|
// Ballot B setup
|
|
signerB.DeserializeHexStr(signerBBLSPublicHex)
|
|
headerHashB, _ := hex.DecodeString(signerBHeaderHashHex)
|
|
hashB = common.BytesToHash(headerHashB)
|
|
// address setup
|
|
reporterAddr, _ = common2.Bech32ToAddress(reporterBech32)
|
|
offenderAddr, _ = common2.Bech32ToAddress(offenderBech32)
|
|
randoDel, _ = common2.Bech32ToAddress(randoDelegatorBech32)
|
|
headerData, err := hex.DecodeString(proposalHeaderRLPBytes)
|
|
if err != nil {
|
|
panic("test case has bad input")
|
|
}
|
|
if err := rlp.DecodeBytes(headerData, &header); err != nil {
|
|
panic("test case has bad input")
|
|
}
|
|
for _, hexK := range [...]string{
|
|
commK1, commK2, commK3, commK4, commK5, commK6,
|
|
} {
|
|
k := &bls.PublicKey{}
|
|
k.DeserializeHexStr(hexK)
|
|
subCommittee = append(subCommittee, *shard.FromLibBLSPublicKeyUnsafe(k))
|
|
}
|
|
return nil
|
|
}()
|
|
|
|
blsWrapA, blsWrapB = *shard.FromLibBLSPublicKeyUnsafe(signerA),
|
|
*shard.FromLibBLSPublicKeyUnsafe(signerB)
|
|
)
|
|
|
|
func (s *scenario) defaultValidatorPair(
|
|
delegationsSnapshot, delegationsCurrent staking.Delegations,
|
|
) (
|
|
*staking.ValidatorWrapper, *staking.ValidatorWrapper,
|
|
) {
|
|
|
|
validatorSnapshot := &staking.ValidatorWrapper{
|
|
Validator: staking.Validator{
|
|
Address: offenderAddr,
|
|
SlotPubKeys: []shard.BLSPublicKey{blsWrapA},
|
|
LastEpochInCommittee: big.NewInt(lastEpochInComm),
|
|
MinSelfDelegation: tenKOnes, //new(big.Int).SetUint64(1 * denominations.One),
|
|
MaxTotalDelegation: hundredKOnes, //new(big.Int).SetUint64(10 * denominations.One),
|
|
Status: effective.Active,
|
|
Commission: commonCommission,
|
|
Description: commonDescr,
|
|
CreationHeight: big.NewInt(creationHeight),
|
|
},
|
|
Delegations: delegationsSnapshot,
|
|
}
|
|
|
|
validatorCurrent := &staking.ValidatorWrapper{
|
|
Validator: staking.Validator{
|
|
Address: offenderAddr,
|
|
SlotPubKeys: []shard.BLSPublicKey{blsWrapA},
|
|
LastEpochInCommittee: big.NewInt(lastEpochInComm + 1),
|
|
MinSelfDelegation: tenKOnes, // new(big.Int).SetUint64(1 * denominations.One),
|
|
MaxTotalDelegation: hundredKOnes, // new(big.Int).SetUint64(10 * denominations.One),
|
|
Status: effective.Active,
|
|
Commission: commonCommission,
|
|
Description: commonDescr,
|
|
CreationHeight: big.NewInt(creationHeight),
|
|
},
|
|
Delegations: delegationsCurrent,
|
|
}
|
|
return validatorSnapshot, validatorCurrent
|
|
}
|
|
|
|
func (s *scenario) defaultDelegationPair() (
|
|
staking.Delegations, staking.Delegations,
|
|
) {
|
|
delegationsSnapshot := staking.Delegations{
|
|
// NOTE delegation is the validator themselves
|
|
staking.Delegation{
|
|
DelegatorAddress: offenderAddr,
|
|
Amount: twentyKOnes, // new(big.Int).SetUint64(2 * denominations.One),
|
|
Reward: common.Big0,
|
|
Undelegations: staking.Undelegations{},
|
|
},
|
|
staking.Delegation{
|
|
DelegatorAddress: randoDel,
|
|
Amount: thirtyKOnes, //new(big.Int).SetUint64(3 * denominations.One),
|
|
Reward: common.Big0,
|
|
Undelegations: staking.Undelegations{},
|
|
},
|
|
}
|
|
|
|
delegationsCurrent := staking.Delegations{
|
|
staking.Delegation{
|
|
DelegatorAddress: offenderAddr,
|
|
Amount: onePointNineSixKOnes, //new(big.Int).SetUint64(1.96 * denominations.One),
|
|
Reward: common.Big0,
|
|
Undelegations: staking.Undelegations{
|
|
staking.Undelegation{
|
|
Amount: tenKOnes, //new(big.Int).SetUint64(1 * denominations.One),
|
|
Epoch: big.NewInt(doubleSignEpoch + 2),
|
|
},
|
|
},
|
|
},
|
|
// some external delegator
|
|
staking.Delegation{
|
|
DelegatorAddress: randoDel,
|
|
Amount: fiveKOnes, //new(big.Int).SetUint64(0.5 * denominations.One),
|
|
Reward: common.Big0,
|
|
Undelegations: staking.Undelegations{
|
|
staking.Undelegation{
|
|
Amount: twentyfiveKOnes, //new(big.Int).SetUint64(2.5 * denominations.One),
|
|
Epoch: big.NewInt(doubleSignEpoch + 2),
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
return delegationsSnapshot, delegationsCurrent
|
|
}
|
|
|
|
func defaultSlashRecord() Record {
|
|
return Record{
|
|
Evidence: Evidence{
|
|
ConflictingBallots: ConflictingBallots{
|
|
AlreadyCastBallot: votepower.Ballot{
|
|
SignerPubKey: blsWrapA,
|
|
BlockHeaderHash: hashA,
|
|
Signature: common.Hex2Bytes(signerABLSSignature),
|
|
Height: doubleSignBlockNumber,
|
|
ViewID: doubleSignViewID,
|
|
},
|
|
DoubleSignedBallot: votepower.Ballot{
|
|
SignerPubKey: blsWrapB,
|
|
BlockHeaderHash: hashB,
|
|
Signature: common.Hex2Bytes(signerBBLSSignature),
|
|
Height: doubleSignBlockNumber,
|
|
ViewID: doubleSignViewID,
|
|
},
|
|
},
|
|
Moment: Moment{
|
|
Epoch: big.NewInt(doubleSignEpoch),
|
|
TimeUnixNano: big.NewInt(doubleSignUnixNano),
|
|
ShardID: doubleSignShardID,
|
|
},
|
|
},
|
|
Reporter: reporterAddr,
|
|
Offender: offenderAddr,
|
|
}
|
|
}
|
|
|
|
func exampleSlashRecords() Records {
|
|
return Records{defaultSlashRecord()}
|
|
}
|
|
|
|
type mockOutSnapshotReader struct {
|
|
snapshot staking.ValidatorSnapshot
|
|
}
|
|
|
|
func (m mockOutSnapshotReader) ReadValidatorSnapshotAtEpoch(
|
|
epoch *big.Int,
|
|
addr common.Address,
|
|
) (*staking.ValidatorSnapshot, error) {
|
|
return &m.snapshot, nil
|
|
}
|
|
|
|
type mockOutChainReader struct{}
|
|
|
|
func (mockOutChainReader) CurrentBlock() *types.Block {
|
|
b := types.Block{}
|
|
b.Header().SetEpoch(doubleSignEpochBig)
|
|
return &b
|
|
}
|
|
|
|
func (mockOutChainReader) ReadShardState(epoch *big.Int) (*shard.State, error) {
|
|
return &shard.State{
|
|
Epoch: doubleSignEpochBig,
|
|
Shards: []shard.Committee{
|
|
{
|
|
ShardID: doubleSignShardID,
|
|
Slots: shard.SlotList{
|
|
shard.Slot{
|
|
EcdsaAddress: offenderAddr,
|
|
BLSPublicKey: blsWrapA,
|
|
EffectiveStake: nil,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
func (mockOutChainReader) Config() *params.ChainConfig {
|
|
return params.TestChainConfig
|
|
}
|
|
|
|
func TestVerify(t *testing.T) {
|
|
stateHandle := defaultStateWithAccountsApplied()
|
|
|
|
if err := Verify(
|
|
mockOutChainReader{}, stateHandle, &exampleSlashRecords()[0],
|
|
); err != nil {
|
|
// TODO
|
|
// t.Errorf("could not verify slash %s", err.Error())
|
|
}
|
|
}
|
|
|
|
func testScenario(
|
|
t *testing.T, stateHandle *state.DB, slashes Records, s *scenario,
|
|
) {
|
|
if err := stateHandle.UpdateValidatorWrapper(
|
|
offenderAddr, s.snapshot,
|
|
); err != nil {
|
|
t.Fatalf("creation of validator failed %s", err.Error())
|
|
}
|
|
|
|
stateHandle.IntermediateRoot(false)
|
|
stateHandle.Commit(false)
|
|
|
|
if err := stateHandle.UpdateValidatorWrapper(
|
|
offenderAddr, s.current,
|
|
); err != nil {
|
|
t.Fatalf("update of validator failed %s", err.Error())
|
|
}
|
|
|
|
stateHandle.IntermediateRoot(false)
|
|
stateHandle.Commit(false)
|
|
// NOTE See dump.json to see what account
|
|
// state looks like as of this point
|
|
|
|
slashResult, err := Apply(
|
|
mockOutSnapshotReader{staking.ValidatorSnapshot{s.snapshot, big.NewInt(0)}},
|
|
stateHandle,
|
|
slashes,
|
|
numeric.MustNewDecFromStr(
|
|
fmt.Sprintf("%f", s.slashRate),
|
|
),
|
|
)
|
|
|
|
if err != nil {
|
|
t.Fatalf("rate: %v, slash application failed %s", s.slashRate, err.Error())
|
|
}
|
|
|
|
if sn := slashResult.TotalSlashed; sn.Cmp(
|
|
s.result.TotalSlashed,
|
|
) != 0 {
|
|
t.Errorf(
|
|
"total slash incorrect have %v want %v",
|
|
sn,
|
|
s.result.TotalSlashed,
|
|
)
|
|
}
|
|
|
|
if sn := slashResult.TotalSnitchReward; sn.Cmp(
|
|
s.result.TotalSnitchReward,
|
|
) != 0 {
|
|
t.Errorf(
|
|
"total snitch incorrect have %v want %v",
|
|
sn,
|
|
s.result.TotalSnitchReward,
|
|
)
|
|
}
|
|
}
|
|
|
|
func defaultStateWithAccountsApplied() *state.DB {
|
|
st := ethdb.NewMemDatabase()
|
|
stateHandle, _ := state.New(common.Hash{}, state.NewDatabase(st))
|
|
for _, addr := range []common.Address{reporterAddr, offenderAddr, randoDel} {
|
|
stateHandle.CreateAccount(addr)
|
|
}
|
|
stateHandle.SetBalance(offenderAddr, big.NewInt(0).SetUint64(1994680320000000000))
|
|
stateHandle.SetBalance(randoDel, big.NewInt(0).SetUint64(1999975592000000000))
|
|
return stateHandle
|
|
}
|
|
|
|
func TestTwoPercentSlashed(t *testing.T) {
|
|
slashes := exampleSlashRecords()
|
|
stateHandle := defaultStateWithAccountsApplied()
|
|
testScenario(t, stateHandle, slashes, scenarioTwoPercent)
|
|
}
|
|
|
|
// func TestEightyPercentSlashed(t *testing.T) {
|
|
// slashes := exampleSlashRecords()
|
|
// stateHandle := defaultStateWithAccountsApplied()
|
|
// testScenario(t, stateHandle, slashes, scenarioEightyPercent)
|
|
// }
|
|
|
|
func TestDoubleSignSlashRates(t *testing.T) {
|
|
for _, scenario := range doubleSignScenarios {
|
|
slashes := exampleSlashRecords()
|
|
stateHandle := defaultStateWithAccountsApplied()
|
|
testScenario(t, stateHandle, slashes, scenario)
|
|
}
|
|
}
|
|
|
|
// Simply testing serialization / deserialization of slash records working correctly
|
|
func TestRoundTripSlashRecord(t *testing.T) {
|
|
slashes := exampleSlashRecords()
|
|
serializedA := slashes.String()
|
|
data, err := rlp.EncodeToBytes(slashes)
|
|
if err != nil {
|
|
t.Errorf("encoding slash records failed %s", err.Error())
|
|
}
|
|
roundTrip := Records{}
|
|
if err := rlp.DecodeBytes(data, &roundTrip); err != nil {
|
|
t.Errorf("decoding slash records failed %s", err.Error())
|
|
}
|
|
serializedB := roundTrip.String()
|
|
if serializedA != serializedB {
|
|
t.Error("rlp encode/decode round trip records failed")
|
|
}
|
|
}
|
|
|
|
func TestSetDifference(t *testing.T) {
|
|
setA, setB := exampleSlashRecords(), exampleSlashRecords()
|
|
additionalSlash := defaultSlashRecord()
|
|
additionalSlash.Evidence.Epoch.Add(additionalSlash.Evidence.Epoch, common.Big1)
|
|
setB = append(setB, additionalSlash)
|
|
diff := setA.SetDifference(setB)
|
|
if diff[0].Hash() != additionalSlash.Hash() {
|
|
t.Errorf("did not get set difference of slash")
|
|
}
|
|
}
|
|
|
|
// TODO bytes used for this example are stale, need to update RLP dump
|
|
// func TestApply(t *testing.T) {
|
|
// slashes := exampleSlashRecords()
|
|
// {
|
|
// stateHandle := defaultStateWithAccountsApplied()
|
|
// testScenario(t, stateHandle, slashes, scenarioRealWorldSample1())
|
|
// }
|
|
// }
|
|
|