New actions integration tests

cmd/nuklai-cli/cmd/action.go

@@ -580,7 +580,7 @@ var registerValidatorStakeCmd = &cobra.Command{
 
 		if autoRegister {
 			hutils.Outf("{{yellow}}Loading private key for %s{{/}}\n", nodeNumber)
-			validatorSignerKey, err := loadPrivateKey("bls", fmt.Sprintf("/tmp/nuklaivm/nodes/%s-bls/signer.key", nodeNumber))
+			validatorSignerKey, err := LoadPrivateKey("bls", fmt.Sprintf("/tmp/nuklaivm/nodes/%s-bls/signer.key", nodeNumber))
 			if err != nil {
 				return err
 			}

cmd/nuklai-cli/cmd/key.go

@@ -91,7 +91,7 @@ func generatePrivateKey(k string) (*cli.PrivateKey, error) {
 	}
 }
 
-func loadPrivateKey(k string, path string) (*cli.PrivateKey, error) {
+func LoadPrivateKey(k string, path string) (*cli.PrivateKey, error) {
 	switch k {
 	case ed25519Key:
 		p, err := hutils.LoadBytes(path, ed25519.PrivateKeyLen)
@@ -187,7 +187,7 @@ var importKeyCmd = &cobra.Command{
 		return checkKeyType(args[0])
 	},
 	RunE: func(_ *cobra.Command, args []string) error {
-		priv, err := loadPrivateKey(args[0], args[1])
+		priv, err := LoadPrivateKey(args[0], args[1])
 		if err != nil {
 			return err
 		}

controller/controller.go

@@ -45,7 +45,7 @@ type Controller struct {
 
 	metaDB database.Database
 
-	emission *emission.Emission // Emission Balancer for NuklaiVM
+	emission emission.Tracker // Emission Balancer for NuklaiVM
 }
 
 func New() *vm.VM {
@@ -123,13 +123,23 @@ func (c *Controller) Initialize(
 
 	// Create builder and gossiper
 	var (
-		build  builder.Builder
-		gossip gossiper.Gossiper
+		build   builder.Builder
+		gossip  gossiper.Gossiper
+		tracker emission.Tracker
 	)
+
+	// Initialize emission balancer
+	emissionAddr, err := codec.ParseAddressBech32(nconsts.HRP, c.genesis.EmissionBalancer.EmissionAddress)
+	if err != nil {
+		return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+	}
+
 	if c.config.TestMode {
 		c.inner.Logger().Info("running build and gossip in test mode")
 		build = builder.NewManual(inner)
 		gossip = gossiper.NewManual(inner)
+		tracker = emission.NewManual(c, c.inner, c.genesis.EmissionBalancer.TotalSupply, c.genesis.EmissionBalancer.MaxSupply, emissionAddr)
+		c.emission = tracker
 	} else {
 		build = builder.NewTime(inner)
 		gcfg := gossiper.DefaultProposerConfig()
@@ -142,15 +152,10 @@ func (c *Controller) Initialize(
 		if err != nil {
 			return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
 		}
+		tracker = emission.NewEmission(c, c.inner, c.genesis.EmissionBalancer.TotalSupply, c.genesis.EmissionBalancer.MaxSupply, emissionAddr)
+		c.emission = tracker
 	}
 
-	// Initialize emission balancer
-	emissionAddr, err := codec.ParseAddressBech32(nconsts.HRP, c.genesis.EmissionBalancer.EmissionAddress)
-	if err != nil {
-		return nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, err
-	}
-	c.emission = emission.New(c, c.inner, c.genesis.EmissionBalancer.TotalSupply, c.genesis.EmissionBalancer.MaxSupply, emissionAddr)
-
 	return c.config, c.genesis, build, gossip, blockDB, stateDB, apis, nconsts.ActionRegistry, nconsts.AuthRegistry, auth.Engines(), nil
 }
 
@@ -255,22 +260,23 @@ func (c *Controller) Accepted(ctx context.Context, blk *chain.StatelessBlock) er
 		}
 	}
 
+	emissionAccount, totalSupply, maxSupply, _, _ := c.emission.GetInfo()
 	// Distribute fees
 	if totalFee > 0 {
 		c.emission.DistributeFees(totalFee)
-		emissionAddress, err := codec.AddressBech32(nconsts.HRP, c.emission.EmissionAccount.Address)
+		emissionAddress, err := codec.AddressBech32(nconsts.HRP, emissionAccount.Address)
 		if err != nil {
 			return err // This should never happen
 		}
-		c.inner.Logger().Info("distributed fees to Emission and Validators", zap.Uint64("current block height", c.inner.LastAcceptedBlock().Height()), zap.Uint64("total fee", totalFee), zap.Uint64("total supply", c.emission.TotalSupply), zap.Uint64("max supply", c.emission.MaxSupply), zap.Uint64("rewards per epock", c.emission.GetRewardsPerEpoch()), zap.String("emission address", emissionAddress), zap.Uint64("emission address unclaimed balance", c.emission.EmissionAccount.UnclaimedBalance))
+		c.inner.Logger().Info("distributed fees to Emission and Validators", zap.Uint64("current block height", c.inner.LastAcceptedBlock().Height()), zap.Uint64("total fee", totalFee), zap.Uint64("total supply", totalSupply), zap.Uint64("max supply", maxSupply), zap.Uint64("rewards per epock", c.emission.GetRewardsPerEpoch()), zap.String("emission address", emissionAddress), zap.Uint64("emission address unclaimed balance", emissionAccount.UnclaimedBalance))
 		c.metrics.feesDistributed.Add(float64(totalFee))
 	}
 
 	// Mint new NAI if needed
 	mintNewNAI := c.emission.MintNewNAI()
 	if mintNewNAI > 0 {
 		c.emission.AddToTotalSupply(mintNewNAI)
-		c.inner.Logger().Info("minted new NAI", zap.Uint64("current block height", c.inner.LastAcceptedBlock().Height()), zap.Uint64("newly minted NAI", mintNewNAI), zap.Uint64("total supply", c.emission.TotalSupply), zap.Uint64("max supply", c.emission.MaxSupply))
+		c.inner.Logger().Info("minted new NAI", zap.Uint64("current block height", c.inner.LastAcceptedBlock().Height()), zap.Uint64("newly minted NAI", mintNewNAI), zap.Uint64("total supply", totalSupply), zap.Uint64("max supply", maxSupply))
 	}
 
 	return batch.Write()

controller/resolutions.go

@@ -59,7 +59,8 @@ func (c *Controller) GetLoanFromState(
 }
 
 func (c *Controller) GetEmissionInfo() (uint64, uint64, uint64, uint64, uint64, emission.EmissionAccount, emission.EpochTracker, error) {
-	return c.emission.GetLastAcceptedBlockHeight(), c.emission.TotalSupply, c.emission.MaxSupply, c.emission.TotalStaked, c.emission.GetRewardsPerEpoch(), c.emission.EmissionAccount, c.emission.EpochTracker, nil
+	emissionAccount, totalSupply, maxSupply, totalStaked, epochTracker := c.emission.GetInfo()
+	return c.emission.GetLastAcceptedBlockHeight(), totalSupply, maxSupply, totalStaked, c.emission.GetRewardsPerEpoch(), emissionAccount, epochTracker, nil
 }
 
 func (c *Controller) GetValidators(ctx context.Context, staked bool) ([]*emission.Validator, error) {

emission/emission.go

@@ -15,37 +15,7 @@ import (
 	"github.com/nuklai/nuklaivm/storage"
 )
 
-var (
-	emission *Emission
-	once     sync.Once
-)
-
-type Validator struct {
-	IsActive                 bool       `json:"isActive"`                 // Indicates if the validator is currently active
-	NodeID                   ids.NodeID `json:"nodeID"`                   // Node ID of the validator
-	PublicKey                []byte     `json:"publicKey"`                // Public key of the validator
-	StakedAmount             uint64     `json:"stakedAmount"`             // Total amount staked by the validator
-	UnclaimedStakedReward    uint64     `json:"stakedReward"`             // Total rewards accumulated by the validator
-	DelegationFeeRate        float64    `json:"delegationFeeRate"`        // Fee rate for delegations
-	DelegatedAmount          uint64     `json:"delegatedAmount"`          // Total amount delegated to the validator
-	UnclaimedDelegatedReward uint64     `json:"unclaimedDelegatedReward"` // Total rewards accumulated by the delegators
-
-	delegatorsLastClaim map[codec.Address]uint64 // Map of delegator addresses to their last claim block height
-	epochRewards        map[uint64]uint64        // Rewards per epoch
-	stakeStartBlock     uint64                   // Start block of the stake
-	stakeEndBlock       uint64                   // End block of the stake
-}
-
-type EmissionAccount struct {
-	Address          codec.Address `json:"address"`
-	UnclaimedBalance uint64        `json:"unclaimedBalance"`
-}
-
-type EpochTracker struct {
-	BaseAPR        float64 `json:"baseAPR"`        // Base APR to use
-	BaseValidators uint64  `json:"baseValidators"` // Base number of validators to use
-	EpochLength    uint64  `json:"epochLength"`    // Number of blocks per reward epoch
-}
+var _ Tracker = (*Emission)(nil)
 
 type Emission struct {
 	c        Controller
@@ -65,7 +35,7 @@ type Emission struct {
 
 // New initializes the Emission struct with initial parameters and sets up the validators heap
 // and indices map.
-func New(c Controller, vm NuklaiVM, totalSupply, maxSupply uint64, emissionAddress codec.Address) *Emission {
+func NewEmission(c Controller, vm NuklaiVM, totalSupply, maxSupply uint64, emissionAddress codec.Address) *Emission {
 	once.Do(func() {
 		c.Logger().Info("Initializing emission with max supply and rewards per block settings")
 
@@ -91,12 +61,7 @@ func New(c Controller, vm NuklaiVM, totalSupply, maxSupply uint64, emissionAddre
 			},
 		}
 	})
-	return emission
-}
-
-// GetEmission returns the singleton instance of Emission
-func GetEmission() *Emission {
-	return emission
+	return emission.(*Emission)
 }
 
 // AddToTotalSupply increases the total supply of NAI by a specified amount, ensuring it
@@ -527,15 +492,6 @@ func (e *Emission) DistributeFees(fee uint64) {
 	}
 }
 
-func distributeValidatorRewards(totalValidatorReward uint64, delegationFeeRate float64, delegatedAmount uint64) (uint64, uint64) {
-	delegationRewards := uint64(0)
-	if delegatedAmount > 0 {
-		delegationRewards = uint64(float64(totalValidatorReward) * delegationFeeRate)
-	}
-	validatorRewards := totalValidatorReward - delegationRewards
-	return validatorRewards, delegationRewards
-}
-
 // GetStakedValidator retrieves the details of a specific validator by their NodeID.
 func (e *Emission) GetStakedValidator(nodeID ids.NodeID) []*Validator {
 	e.c.Logger().Info("fetching staked validator")
@@ -591,3 +547,12 @@ func (e *Emission) GetLastAcceptedBlockHeight() uint64 {
 	e.c.Logger().Info("fetching last accepted block height")
 	return e.nuklaivm.LastAcceptedBlock().Height()
 }
+
+func (e *Emission) GetEmissionValidators() map[ids.NodeID]*Validator {
+	e.c.Logger().Info("fetching emission validators")
+	return e.validators
+}
+
+func (e *Emission) GetInfo() (emissionAccount EmissionAccount, totalSupply uint64, maxSupply uint64, totalStaked uint64, epochTracker EpochTracker) {
+	return e.EmissionAccount, e.TotalSupply, e.MaxSupply, e.TotalStaked, e.EpochTracker
+}

emission/helpers.go

@@ -0,0 +1,49 @@
+package emission
+
+import (
+	"sync"
+
+	"github.com/ava-labs/avalanchego/ids"
+	"github.com/ava-labs/hypersdk/codec"
+)
+
+var (
+	once     sync.Once
+	emission Tracker
+)
+
+type Validator struct {
+	IsActive                 bool       `json:"isActive"`          // Indicates if the validator is currently active
+	NodeID                   ids.NodeID `json:"nodeID"`            // Node ID of the validator
+	PublicKey                []byte     `json:"publicKey"`         // Public key of the validator
+	StakedAmount             uint64     `json:"stakedAmount"`      // Total amount staked by the validator
+	UnclaimedStakedReward    uint64     `json:"stakedReward"`      // Total rewards accumulated by the validator
+	DelegationFeeRate        float64    `json:"delegationFeeRate"` // Fee rate for delegations
+	DelegatedAmount          uint64     `json:"delegatedAmount"`   // Total amount delegated to the validator
+	UnclaimedDelegatedReward uint64     `json:"delegatedReward"`   // Total rewards accumulated by the delegators
+
+	delegatorsLastClaim map[codec.Address]uint64 // Map of delegator addresses to their last claim block height
+	epochRewards        map[uint64]uint64        // Rewards per epoch
+	stakeStartBlock     uint64                   // Start block of the stake
+	stakeEndBlock       uint64                   // End block of the stake
+}
+
+type EmissionAccount struct {
+	Address          codec.Address `json:"address"`
+	UnclaimedBalance uint64        `json:"unclaimedBalance"`
+}
+
+type EpochTracker struct {
+	BaseAPR        float64 `json:"baseAPR"`        // Base APR to use
+	BaseValidators uint64  `json:"baseValidators"` // Base number of validators to use
+	EpochLength    uint64  `json:"epochLength"`    // Number of blocks per reward epoch
+}
+
+func distributeValidatorRewards(totalValidatorReward uint64, delegationFeeRate float64, delegatedAmount uint64) (uint64, uint64) {
+	delegationRewards := uint64(0)
+	if delegatedAmount > 0 {
+		delegationRewards = uint64(float64(totalValidatorReward) * delegationFeeRate)
+	}
+	validatorRewards := totalValidatorReward - delegationRewards
+	return validatorRewards, delegationRewards
+}