mark repository methods private (#1291)

libotony · web-flow · commit 9491f7944906 · 2025-08-28T17:13:09.000+08:00
diff --git a/builtin/staker/validation/repository.go b/builtin/staker/validation/repository.go
@@ -6,6 +6,7 @@
 package validation
 
 import (
+	"encoding/binary"
 	"math/big"
 
 	"github.com/pkg/errors"
@@ -24,18 +25,18 @@ type Repository struct {
 	validations *solidity.Mapping[thor.Address, Validation]
 	rewards     *solidity.Mapping[thor.Bytes32, *big.Int] // stores rewards per validator staking period
 
-	exits *solidity.Mapping[*big.Int, thor.Address] // exit block -> validator ID
+	exits *solidity.Mapping[thor.Bytes32, thor.Address] // exit block -> validator ID
 }
 
 func NewRepository(sctx *solidity.Context) *Repository {
 	return &Repository{
 		validations: solidity.NewMapping[thor.Address, Validation](sctx, slotValidations),
 		rewards:     solidity.NewMapping[thor.Bytes32, *big.Int](sctx, slotRewards),
-		exits:       solidity.NewMapping[*big.Int, thor.Address](sctx, slotExitEpochs),
+		exits:       solidity.NewMapping[thor.Bytes32, thor.Address](sctx, slotExitEpochs),
 	}
 }
 
-func (r *Repository) GetValidation(validator thor.Address) (*Validation, error) {
+func (r *Repository) getValidation(validator thor.Address) (*Validation, error) {
 	v, err := r.validations.Get(validator)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to get validator")
@@ -50,7 +51,7 @@ func (r *Repository) setValidation(validator thor.Address, entry *Validation, is
 	return nil
 }
 
-func (r *Repository) GetReward(key thor.Bytes32) (*big.Int, error) {
+func (r *Repository) getReward(key thor.Bytes32) (*big.Int, error) {
 	reward, err := r.rewards.Get(key)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to get reward")
@@ -61,18 +62,22 @@ func (r *Repository) GetReward(key thor.Bytes32) (*big.Int, error) {
 	return reward, nil
 }
 
-func (r *Repository) SetReward(key thor.Bytes32, val *big.Int, isNew bool) error {
+func (r *Repository) setReward(key thor.Bytes32, val *big.Int, isNew bool) error {
 	return r.rewards.Set(key, val, isNew)
 }
 
-func (r *Repository) GetExit(block *big.Int) (thor.Address, error) {
-	return r.exits.Get(block)
+func (r *Repository) getExit(block uint32) (thor.Address, error) {
+	var key thor.Bytes32
+	binary.BigEndian.PutUint32(key[:], block)
+
+	return r.exits.Get(key)
 }
 
-func (r *Repository) SetExit(block uint32, validator thor.Address) error {
-	bigBlock := big.NewInt(0).SetUint64(uint64(block))
+func (r *Repository) setExit(block uint32, validator thor.Address) error {
+	var key thor.Bytes32
+	binary.BigEndian.PutUint32(key[:], block)
 
-	if err := r.exits.Set(bigBlock, validator, true); err != nil {
+	if err := r.exits.Set(key, validator, true); err != nil {
 		return errors.Wrap(err, "failed to set exit epoch")
 	}
 	return nil
diff --git a/builtin/staker/validation/repository_test.go b/builtin/staker/validation/repository_test.go
@@ -38,7 +38,7 @@ func TestRepository_Validation_RoundTrip(t *testing.T) {
 
 	assert.NoError(t, repo.setValidation(id, entry, true))
 
-	got, err := repo.GetValidation(id)
+	got, err := repo.getValidation(id)
 	assert.NoError(t, err)
 	assert.Equal(t, entry.Endorser, got.Endorser)
 	assert.Equal(t, uint32(15), got.Period)
@@ -55,7 +55,7 @@ func TestRepository_Validation_GetError(t *testing.T) {
 	slot := thor.Blake2b(id.Bytes(), slotValidations.Bytes())
 	st.SetRawStorage(addr, slot, rlp.RawValue{0xFF})
 
-	_, err := repo.GetValidation(id)
+	_, err := repo.getValidation(id)
 	assert.ErrorContains(t, err, "failed to get validator")
 }
 
@@ -64,15 +64,15 @@ func TestRepository_Reward_RoundTrip_DefaultZero(t *testing.T) {
 	key := thor.BytesToBytes32([]byte("r1"))
 
 	// get before set -> zero
-	val, err := repo.GetReward(key)
+	val, err := repo.getReward(key)
 	assert.NoError(t, err)
 	assert.Equal(t, big.NewInt(0), val)
 
 	// set then get
 	want := big.NewInt(1234)
-	assert.NoError(t, repo.SetReward(key, want, true))
+	assert.NoError(t, repo.setReward(key, want, true))
 
-	got, err := repo.GetReward(key)
+	got, err := repo.getReward(key)
 	assert.NoError(t, err)
 	assert.Equal(t, want, got)
 }
@@ -85,17 +85,17 @@ func TestRepository_Reward_GetError(t *testing.T) {
 	slot := thor.Blake2b(key.Bytes(), slotRewards.Bytes())
 	st.SetRawStorage(addr, slot, rlp.RawValue{0xFF})
 
-	_, err := repo.GetReward(key)
+	_, err := repo.getReward(key)
 	assert.ErrorContains(t, err, "failed to get reward")
 }
 
 func TestRepository_Exit_RoundTrip(t *testing.T) {
 	repo, _, _ := newRepo(t)
 	validator := thor.BytesToAddress([]byte("v3"))
 
-	assert.NoError(t, repo.SetExit(42, validator))
+	assert.NoError(t, repo.setExit(42, validator))
 
-	addr, err := repo.GetExit(big.NewInt(42))
+	addr, err := repo.getExit(42)
 	assert.NoError(t, err)
 	assert.Equal(t, validator, addr)
 }
diff --git a/builtin/staker/validation/service.go b/builtin/staker/validation/service.go
@@ -76,18 +76,18 @@ func (s *Service) IncreaseDelegatorsReward(node thor.Address, reward *big.Int) e
 	binary.BigEndian.PutUint32(periodBytes, val.CurrentIteration())
 	key := thor.Blake2b([]byte("rewards"), node.Bytes(), periodBytes)
 
-	rewards, err := s.repo.GetReward(key)
+	rewards, err := s.repo.getReward(key)
 	if err != nil {
 		return err
 	}
 
-	return s.repo.SetReward(key, big.NewInt(0).Add(rewards, reward), false)
+	return s.repo.setReward(key, big.NewInt(0).Add(rewards, reward), false)
 }
 
 func (s *Service) LeaderGroupIterator(callbacks ...func(thor.Address, *Validation) error) error {
 	return s.leaderGroup.Iter(func(address thor.Address) error {
 		// Fetch the validation object for this address
-		validation, err := s.repo.GetValidation(address)
+		validation, err := s.repo.getValidation(address)
 		if err != nil {
 			return err
 		}
@@ -421,7 +421,7 @@ func (s *Service) SetExitBlock(validator thor.Address, minBlock uint32) (uint32,
 			return start, nil
 		}
 		if existing.IsZero() {
-			if err = s.repo.SetExit(start, validator); err != nil {
+			if err = s.repo.setExit(start, validator); err != nil {
 				return 0, errors.Wrap(err, "failed to set exit epoch")
 			}
 			return start, nil
@@ -431,9 +431,7 @@ func (s *Service) SetExitBlock(validator thor.Address, minBlock uint32) (uint32,
 }
 
 func (s *Service) GetExitEpoch(block uint32) (thor.Address, error) {
-	bigBlock := big.NewInt(0).SetUint64(uint64(block))
-
-	validator, err := s.repo.GetExit(bigBlock)
+	validator, err := s.repo.getExit(block)
 	if err != nil {
 		return thor.Address{}, errors.Wrap(err, "failed to get exit epoch")
 	}
@@ -445,7 +443,7 @@ func (s *Service) GetDelegatorRewards(validator thor.Address, stakingPeriod uint
 	binary.BigEndian.PutUint32(periodBytes, stakingPeriod)
 	key := thor.Blake2b([]byte("rewards"), validator.Bytes(), periodBytes)
 
-	return s.repo.GetReward(key)
+	return s.repo.getReward(key)
 }
 
 // ActivateValidator transitions a validator from queued to active status.
@@ -542,7 +540,7 @@ func (s *Service) Renew(validator thor.Address, delegationWeight uint64) (*delta
 //
 
 func (s *Service) GetValidation(validator thor.Address) (*Validation, error) {
-	return s.repo.GetValidation(validator)
+	return s.repo.getValidation(validator)
 }
 
 func (s *Service) GetExistingValidation(validator thor.Address) (*Validation, error) {
diff --git a/builtin/staker/validation/service_test.go b/builtin/staker/validation/service_test.go
@@ -22,8 +22,9 @@ import (
 )
 
 func poisonExitSlot(st *state.State, contract thor.Address, block uint32) {
-	bigBlock := big.NewInt(0).SetUint64(uint64(block))
-	slot := thor.Blake2b(bigBlock.Bytes(), slotExitEpochs.Bytes())
+	var key thor.Bytes32
+	binary.BigEndian.PutUint32(key[:], block)
+	slot := thor.Blake2b(key[:], slotExitEpochs.Bytes())
 	st.SetRawStorage(contract, slot, rlp.RawValue{0xFF})
 }
 
diff --git a/thor/config.go b/thor/config.go
@@ -19,7 +19,7 @@ var (
 	mediumStakingPeriod uint32 = 8640 * 15 // 15 Days
 	highStakingPeriod   uint32 = 8640 * 30 // 30 Days
 	cooldownPeriod      uint32 = 8640      // 8640 blocks, 1 day
-	hayabusaTP          uint32 = 360 * 24 * 14
+	hayabusaTP          uint32 = 8640 * 14 // 14 days
 
 	locked bool
 )
@@ -89,38 +89,47 @@ func LockConfig() {
 	locked = true
 }
 
+// default value is 10 seconds
 func BlockInterval() uint64 {
 	return blockInterval
 }
 
+// default value is 180 blocks, 30 minutes
 func EpochLength() uint32 {
 	return epochLength
 }
 
+// default value is 8640 blocks, 1 day
 func SeederInterval() uint32 {
 	return seederInterval
 }
 
+// default value is 7 days
 func ValidatorEvictionThreshold() uint32 {
 	return validatorEvictionThreshold
 }
 
+// default value is 7 days
 func LowStakingPeriod() uint32 {
 	return lowStakingPeriod
 }
 
+// default value is 15 days
 func MediumStakingPeriod() uint32 {
 	return mediumStakingPeriod
 }
 
+// default value is 30 days
 func HighStakingPeriod() uint32 {
 	return highStakingPeriod
 }
 
+// default value is 1 day
 func CooldownPeriod() uint32 {
 	return cooldownPeriod
 }
 
+// default value is 14 days
 func HayabusaTP() uint32 {
 	return hayabusaTP
 }

Original file line number	Diff line number	Diff line change
`@@ -76,18 +76,18 @@ func (s Service) IncreaseDelegatorsReward(node thor.Address, reward big.Int) e`
`76`	`76`	`binary.BigEndian.PutUint32(periodBytes, val.CurrentIteration())`
`77`	`77`	`key := thor.Blake2b([]byte("rewards"), node.Bytes(), periodBytes)`
`78`	`78`
`79`		`- rewards, err := s.repo.GetReward(key)`
	`79`	`+ rewards, err := s.repo.getReward(key)`
`80`	`80`	`if err != nil {`
`81`	`81`	`return err`
`82`	`82`	`}`
`83`	`83`
`84`		`- return s.repo.SetReward(key, big.NewInt(0).Add(rewards, reward), false)`
	`84`	`+ return s.repo.setReward(key, big.NewInt(0).Add(rewards, reward), false)`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`func (s Service) LeaderGroupIterator(callbacks ...func(thor.Address, Validation) error) error {`
`88`	`88`	`return s.leaderGroup.Iter(func(address thor.Address) error {`
`89`	`89`	`// Fetch the validation object for this address`
`90`		`- validation, err := s.repo.GetValidation(address)`
	`90`	`+ validation, err := s.repo.getValidation(address)`
`91`	`91`	`if err != nil {`
`92`	`92`	`return err`
`93`	`93`	`}`
`@@ -421,7 +421,7 @@ func (s *Service) SetExitBlock(validator thor.Address, minBlock uint32) (uint32,`
`421`	`421`	`return start, nil`
`422`	`422`	`}`
`423`	`423`	`if existing.IsZero() {`
`424`		`- if err = s.repo.SetExit(start, validator); err != nil {`
	`424`	`+ if err = s.repo.setExit(start, validator); err != nil {`
`425`	`425`	`return 0, errors.Wrap(err, "failed to set exit epoch")`
`426`	`426`	`}`
`427`	`427`	`return start, nil`
`@@ -431,9 +431,7 @@ func (s *Service) SetExitBlock(validator thor.Address, minBlock uint32) (uint32,`
`431`	`431`	`}`
`432`	`432`
`433`	`433`	`func (s *Service) GetExitEpoch(block uint32) (thor.Address, error) {`
`434`		`- bigBlock := big.NewInt(0).SetUint64(uint64(block))`
`435`		`-`
`436`		`- validator, err := s.repo.GetExit(bigBlock)`
	`434`	`+ validator, err := s.repo.getExit(block)`
`437`	`435`	`if err != nil {`
`438`	`436`	`return thor.Address{}, errors.Wrap(err, "failed to get exit epoch")`
`439`	`437`	`}`
`@@ -445,7 +443,7 @@ func (s *Service) GetDelegatorRewards(validator thor.Address, stakingPeriod uint`
`445`	`443`	`binary.BigEndian.PutUint32(periodBytes, stakingPeriod)`
`446`	`444`	`key := thor.Blake2b([]byte("rewards"), validator.Bytes(), periodBytes)`
`447`	`445`
`448`		`- return s.repo.GetReward(key)`
	`446`	`+ return s.repo.getReward(key)`
`449`	`447`	`}`
`450`	`448`
`451`	`449`	`// ActivateValidator transitions a validator from queued to active status.`
`@@ -542,7 +540,7 @@ func (s Service) Renew(validator thor.Address, delegationWeight uint64) (delta`
`542`	`540`	`//`
`543`	`541`
`544`	`542`	`func (s Service) GetValidation(validator thor.Address) (Validation, error) {`
`545`		`- return s.repo.GetValidation(validator)`
	`543`	`+ return s.repo.getValidation(validator)`
`546`	`544`	`}`
`547`	`545`
`548`	`546`	`func (s Service) GetExistingValidation(validator thor.Address) (Validation, error) {`
Original file line number	Diff line number	Diff line change
`@@ -22,8 +22,9 @@ import (`
`22`	`22`	`)`
`23`	`23`
`24`	`24`	`func poisonExitSlot(st *state.State, contract thor.Address, block uint32) {`
`25`		`- bigBlock := big.NewInt(0).SetUint64(uint64(block))`
`26`		`- slot := thor.Blake2b(bigBlock.Bytes(), slotExitEpochs.Bytes())`
	`25`	`+ var key thor.Bytes32`
	`26`	`+ binary.BigEndian.PutUint32(key[:], block)`
	`27`	`+ slot := thor.Blake2b(key[:], slotExitEpochs.Bytes())`
`27`	`28`	`st.SetRawStorage(contract, slot, rlp.RawValue{0xFF})`
`28`	`29`	`}`
`29`	`30`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ var (`
`19`	`19`	`mediumStakingPeriod uint32 = 8640 * 15 // 15 Days`
`20`	`20`	`highStakingPeriod uint32 = 8640 * 30 // 30 Days`
`21`	`21`	`cooldownPeriod uint32 = 8640 // 8640 blocks, 1 day`
`22`		`- hayabusaTP uint32 = 360 * 24 * 14`
	`22`	`+ hayabusaTP uint32 = 8640 * 14 // 14 days`
`23`	`23`
`24`	`24`	`locked bool`
`25`	`25`	`)`
`@@ -89,38 +89,47 @@ func LockConfig() {`
`89`	`89`	`locked = true`
`90`	`90`	`}`
`91`	`91`
	`92`	`+// default value is 10 seconds`
`92`	`93`	`func BlockInterval() uint64 {`
`93`	`94`	`return blockInterval`
`94`	`95`	`}`
`95`	`96`
	`97`	`+// default value is 180 blocks, 30 minutes`
`96`	`98`	`func EpochLength() uint32 {`
`97`	`99`	`return epochLength`
`98`	`100`	`}`
`99`	`101`
	`102`	`+// default value is 8640 blocks, 1 day`
`100`	`103`	`func SeederInterval() uint32 {`
`101`	`104`	`return seederInterval`
`102`	`105`	`}`
`103`	`106`
	`107`	`+// default value is 7 days`
`104`	`108`	`func ValidatorEvictionThreshold() uint32 {`
`105`	`109`	`return validatorEvictionThreshold`
`106`	`110`	`}`
`107`	`111`
	`112`	`+// default value is 7 days`
`108`	`113`	`func LowStakingPeriod() uint32 {`
`109`	`114`	`return lowStakingPeriod`
`110`	`115`	`}`
`111`	`116`
	`117`	`+// default value is 15 days`
`112`	`118`	`func MediumStakingPeriod() uint32 {`
`113`	`119`	`return mediumStakingPeriod`
`114`	`120`	`}`
`115`	`121`
	`122`	`+// default value is 30 days`
`116`	`123`	`func HighStakingPeriod() uint32 {`
`117`	`124`	`return highStakingPeriod`
`118`	`125`	`}`
`119`	`126`
	`127`	`+// default value is 1 day`
`120`	`128`	`func CooldownPeriod() uint32 {`
`121`	`129`	`return cooldownPeriod`
`122`	`130`	`}`
`123`	`131`
	`132`	`+// default value is 14 days`
`124`	`133`	`func HayabusaTP() uint32 {`
`125`	`134`	`return hayabusaTP`
`126`	`135`	`}`