mirror of
https://github.com/luxfi/node.git
synced 2026-10-30 15:24:05 +00:00
zeekay
7cf87b230b
The module already called itself github.com/luxfi/node while containing no node in Go: cmd/luxd was twenty-one lines that printed the size of a few types, and the Go column of the matrix measured a VM plugin. A repo that fetches the thing it claims to be has not replaced it, so the Go sources move in — 1515 files, the daemon and everything under it — and the build reaches outside this module for nothing. Rust and C++ sit beside it unchanged and are still measured against it by the differential. That is the point of one repo: the reference implementation and the two ports are the same checkout, so parity is a thing you can run rather than a thing you assert. Verified: builds, and the closure carries no lux-private — checked at build time rather than believed. The daemon starts twelve chains on a local network (P X C Q Z A B G K M F, plus D through its plugin) and reports healthy.
246 lines
7.3 KiB
Go
246 lines
7.3 KiB
Go
// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved.
|
|
// See the file LICENSE for licensing terms.
|
|
|
|
package state
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/luxfi/database"
|
|
"github.com/luxfi/database/memdb"
|
|
"github.com/luxfi/ids"
|
|
)
|
|
|
|
func TestValidatorUptimes(t *testing.T) {
|
|
require := require.New(t)
|
|
state := newValidatorState()
|
|
|
|
// get non-existent uptime
|
|
nodeID := ids.GenerateTestNodeID()
|
|
netID := ids.GenerateTestID()
|
|
_, _, err := state.GetUptime(nodeID, netID)
|
|
require.ErrorIs(err, database.ErrNotFound)
|
|
|
|
// set non-existent uptime
|
|
err = state.SetUptime(nodeID, netID, 1, time.Now())
|
|
require.ErrorIs(err, database.ErrNotFound)
|
|
|
|
testMetadata := &validatorMetadata{
|
|
UpDuration: time.Hour,
|
|
lastUpdated: time.Now(),
|
|
}
|
|
// load uptime
|
|
state.LoadValidatorMetadata(nodeID, netID, testMetadata)
|
|
|
|
// get uptime
|
|
upDuration, lastUpdated, err := state.GetUptime(nodeID, netID)
|
|
require.NoError(err)
|
|
require.Equal(testMetadata.UpDuration, upDuration)
|
|
require.Equal(testMetadata.lastUpdated, lastUpdated)
|
|
|
|
// set uptime
|
|
newUpDuration := testMetadata.UpDuration + 1
|
|
newLastUpdated := testMetadata.lastUpdated.Add(time.Hour)
|
|
require.NoError(state.SetUptime(nodeID, netID, newUpDuration, newLastUpdated))
|
|
|
|
// get new uptime
|
|
upDuration, lastUpdated, err = state.GetUptime(nodeID, netID)
|
|
require.NoError(err)
|
|
require.Equal(newUpDuration, upDuration)
|
|
require.Equal(newLastUpdated, lastUpdated)
|
|
|
|
// load uptime changes uptimes
|
|
newTestMetadata := &validatorMetadata{
|
|
UpDuration: testMetadata.UpDuration + time.Hour,
|
|
lastUpdated: testMetadata.lastUpdated.Add(time.Hour),
|
|
}
|
|
state.LoadValidatorMetadata(nodeID, netID, newTestMetadata)
|
|
|
|
// get new uptime
|
|
upDuration, lastUpdated, err = state.GetUptime(nodeID, netID)
|
|
require.NoError(err)
|
|
require.Equal(newTestMetadata.UpDuration, upDuration)
|
|
require.Equal(newTestMetadata.lastUpdated, lastUpdated)
|
|
|
|
// delete uptime
|
|
state.DeleteValidatorMetadata(nodeID, netID)
|
|
|
|
// get deleted uptime
|
|
_, _, err = state.GetUptime(nodeID, netID)
|
|
require.ErrorIs(err, database.ErrNotFound)
|
|
}
|
|
|
|
func TestWriteValidatorMetadata(t *testing.T) {
|
|
require := require.New(t)
|
|
state := newValidatorState()
|
|
|
|
primaryDB := memdb.New()
|
|
chainDB := memdb.New()
|
|
|
|
// write empty uptimes
|
|
require.NoError(state.WriteValidatorMetadata(primaryDB, chainDB))
|
|
|
|
// load uptime
|
|
nodeID := ids.GenerateTestNodeID()
|
|
netID := ids.GenerateTestID()
|
|
testUptimeReward := &validatorMetadata{
|
|
UpDuration: time.Hour,
|
|
lastUpdated: time.Now(),
|
|
PotentialReward: 100,
|
|
txID: ids.GenerateTestID(),
|
|
}
|
|
state.LoadValidatorMetadata(nodeID, netID, testUptimeReward)
|
|
|
|
// write state, should not reflect to DB yet
|
|
require.NoError(state.WriteValidatorMetadata(primaryDB, chainDB))
|
|
require.False(primaryDB.Has(testUptimeReward.txID[:]))
|
|
require.False(chainDB.Has(testUptimeReward.txID[:]))
|
|
|
|
// get uptime should still return the loaded value
|
|
upDuration, lastUpdated, err := state.GetUptime(nodeID, netID)
|
|
require.NoError(err)
|
|
require.Equal(testUptimeReward.UpDuration, upDuration)
|
|
require.Equal(testUptimeReward.lastUpdated, lastUpdated)
|
|
|
|
// update uptimes
|
|
newUpDuration := testUptimeReward.UpDuration + 1
|
|
newLastUpdated := testUptimeReward.lastUpdated.Add(time.Hour)
|
|
require.NoError(state.SetUptime(nodeID, netID, newUpDuration, newLastUpdated))
|
|
|
|
// write uptimes, should reflect to net DB
|
|
require.NoError(state.WriteValidatorMetadata(primaryDB, chainDB))
|
|
require.False(primaryDB.Has(testUptimeReward.txID[:]))
|
|
require.True(chainDB.Has(testUptimeReward.txID[:]))
|
|
}
|
|
|
|
func TestValidatorDelegateeRewards(t *testing.T) {
|
|
require := require.New(t)
|
|
state := newValidatorState()
|
|
|
|
// get non-existent delegatee reward
|
|
nodeID := ids.GenerateTestNodeID()
|
|
netID := ids.GenerateTestID()
|
|
_, err := state.GetDelegateeReward(netID, nodeID)
|
|
require.ErrorIs(err, database.ErrNotFound)
|
|
|
|
// set non-existent delegatee reward
|
|
err = state.SetDelegateeReward(netID, nodeID, 100000)
|
|
require.ErrorIs(err, database.ErrNotFound)
|
|
|
|
testMetadata := &validatorMetadata{
|
|
PotentialDelegateeReward: 100000,
|
|
}
|
|
// load delegatee reward
|
|
state.LoadValidatorMetadata(nodeID, netID, testMetadata)
|
|
|
|
// get delegatee reward
|
|
delegateeReward, err := state.GetDelegateeReward(netID, nodeID)
|
|
require.NoError(err)
|
|
require.Equal(testMetadata.PotentialDelegateeReward, delegateeReward)
|
|
|
|
// set delegatee reward
|
|
newDelegateeReward := testMetadata.PotentialDelegateeReward + 100000
|
|
require.NoError(state.SetDelegateeReward(netID, nodeID, newDelegateeReward))
|
|
|
|
// get new delegatee reward
|
|
delegateeReward, err = state.GetDelegateeReward(netID, nodeID)
|
|
require.NoError(err)
|
|
require.Equal(newDelegateeReward, delegateeReward)
|
|
|
|
// load delegatee reward changes
|
|
newTestMetadata := &validatorMetadata{
|
|
PotentialDelegateeReward: testMetadata.PotentialDelegateeReward + 100000,
|
|
}
|
|
state.LoadValidatorMetadata(nodeID, netID, newTestMetadata)
|
|
|
|
// get new delegatee reward
|
|
delegateeReward, err = state.GetDelegateeReward(netID, nodeID)
|
|
require.NoError(err)
|
|
require.Equal(newTestMetadata.PotentialDelegateeReward, delegateeReward)
|
|
|
|
// delete delegatee reward
|
|
state.DeleteValidatorMetadata(nodeID, netID)
|
|
|
|
// get deleted delegatee reward
|
|
_, _, err = state.GetUptime(nodeID, netID)
|
|
require.ErrorIs(err, database.ErrNotFound)
|
|
}
|
|
|
|
func TestParseValidatorMetadata(t *testing.T) {
|
|
// full is a fully-populated record round-tripped through the native wire.
|
|
full := &validatorMetadata{
|
|
UpDuration: 6000000,
|
|
LastUpdated: 900000,
|
|
PotentialReward: 100000,
|
|
PotentialDelegateeReward: 20000,
|
|
StakerStartTime: 12345,
|
|
}
|
|
fullBytes, err := marshalValidatorMetadata(full)
|
|
require.NoError(t, err)
|
|
|
|
type test struct {
|
|
name string
|
|
bytes []byte
|
|
initial *validatorMetadata // caller-supplied defaults before parse
|
|
want *validatorMetadata
|
|
wantErr bool
|
|
}
|
|
tests := []test{
|
|
{
|
|
// Empty ⇒ nothing persisted; caller's tx-derived defaults are kept,
|
|
// only lastUpdated is derived from LastUpdated.
|
|
name: "nil keeps defaults",
|
|
bytes: nil,
|
|
initial: &validatorMetadata{StakerStartTime: 900000, LastUpdated: 900000},
|
|
want: &validatorMetadata{
|
|
StakerStartTime: 900000,
|
|
LastUpdated: 900000,
|
|
lastUpdated: time.Unix(900000, 0),
|
|
},
|
|
},
|
|
{
|
|
name: "empty keeps defaults",
|
|
bytes: []byte{},
|
|
initial: &validatorMetadata{},
|
|
want: &validatorMetadata{lastUpdated: time.Unix(0, 0)},
|
|
},
|
|
{
|
|
// Full native buffer overwrites every serialized field, including the
|
|
// caller's tx-default StakerStartTime.
|
|
name: "full native round-trip",
|
|
bytes: fullBytes,
|
|
initial: &validatorMetadata{StakerStartTime: 999},
|
|
want: &validatorMetadata{
|
|
UpDuration: 6000000,
|
|
LastUpdated: 900000,
|
|
PotentialReward: 100000,
|
|
PotentialDelegateeReward: 20000,
|
|
StakerStartTime: 12345,
|
|
lastUpdated: time.Unix(900000, 0),
|
|
},
|
|
},
|
|
{
|
|
name: "truncated buffer errors",
|
|
bytes: fullBytes[:len(fullBytes)-1],
|
|
initial: &validatorMetadata{},
|
|
wantErr: true,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
require := require.New(t)
|
|
metadata := tt.initial
|
|
err := parseValidatorMetadata(tt.bytes, metadata)
|
|
if tt.wantErr {
|
|
require.Error(err)
|
|
return
|
|
}
|
|
require.NoError(err)
|
|
require.Equal(tt.want, metadata)
|
|
})
|
|
}
|
|
}
|