Sd utilize

.golangci.yml

@@ -33,7 +33,6 @@ linters:
     - gocritic
     - gofmt
     - goimports
-    - gomnd
     - gocyclo
     - gosec
     - gosimple

shared/services/services.go

@@ -223,6 +223,15 @@ func GetStakePoolManagerAddress(c *cli.Context) (common.Address, error) {
 	return stader_config.GetStakePoolManagerAddress(sdcfg, nil)
 }
 
+func GetSdUtilityAddress(c *cli.Context) (common.Address, error) {
+	sdcfg, err := GetStaderConfigContract(c)
+	if err != nil {
+		return common.Address{}, err
+	}
+
+	return stader_config.GetSDUtilityPoolAddress(sdcfg, nil)
+}
+
 func GetPermissionlessNodeRegistry(c *cli.Context) (*stader.PermissionlessNodeRegistryContractManager, error) {
 	cfg, err := getConfig(c)
 	if err != nil {
@@ -422,6 +431,25 @@ func GetStakePoolManager(c *cli.Context) (*stader.StakePoolManagerContractManage
 	return stader.NewStakePoolManager(ec, stakePoolManagerAddress)
 }
 
+func GetSdUtilityContract(c *cli.Context) (*stader.SDUtilityPoolContractManager, error) {
+	_cfg, err := getConfig(c)
+	if err != nil {
+		return nil, err
+	}
+
+	ec, err := getEthClient(c, _cfg)
+	if err != nil {
+		return nil, err
+	}
+
+	sdUtilityAddress, err := GetSdUtilityAddress(c)
+	if err != nil {
+		return nil, err
+	}
+
+	return stader.NewSDUtilityPool(ec, sdUtilityAddress)
+}
+
 func GetBeaconClient(c *cli.Context) (*BeaconClientManager, error) {
 	cfg, err := getConfig(c)
 	if err != nil {

shared/services/stader/client.go

@@ -795,7 +795,6 @@ func (c *Client) GetDockerContainerShutdownTime(container string) (time.Time, er
 }
 
 func (c *Client) UpdateGuardianConfiguration(contents []byte) error {
-
 	guardianTemplatePath, err := homedir.Expand(fmt.Sprintf("%s/%s/%s", c.configPath, templatesDir, GuardianFileTemplate))
 	if err != nil {
 		return fmt.Errorf("error expanding Guardian template path: %w", err)

shared/services/stader/node.go

@@ -207,8 +207,8 @@ func (c *Client) GetNodeDepositSdAllowance() (api.NodeDepositSdAllowanceResponse
 }
 
 // Check whether the node can make a deposit
-func (c *Client) CanNodeDeposit(amountWei *big.Int, numValidators *big.Int, reloadKeys bool) (api.CanNodeDepositResponse, error) {
-	responseBytes, err := c.callAPI(fmt.Sprintf("validator can-deposit %s %s %t", amountWei.String(), numValidators, reloadKeys))
+func (c *Client) CanNodeDeposit(amountBasedWei, amountUtilityWei, numValidators *big.Int, reloadKeys bool) (api.CanNodeDepositResponse, error) {
+	responseBytes, err := c.callAPI(fmt.Sprintf("validator can-deposit %s %s %s %t", amountBasedWei.String(), amountUtilityWei.String(), numValidators, reloadKeys))
 	if err != nil {
 		return api.CanNodeDepositResponse{}, fmt.Errorf("could not get can validator deposit status: %w", err)
 	}
@@ -268,8 +268,8 @@ func (c *Client) GetContractsInfo() (api.ContractsInfoResponse, error) {
 }
 
 // Make a node deposit
-func (c *Client) NodeDeposit(amountWei *big.Int, numValidators *big.Int, reloadKeys bool) (api.NodeDepositResponse, error) {
-	responseBytes, err := c.callAPI(fmt.Sprintf("validator deposit %s %s %t", amountWei.String(), numValidators, reloadKeys))
+func (c *Client) NodeDeposit(amountWei, numValidators, utilitySDAmount *big.Int, reloadKeys bool) (api.NodeDepositResponse, error) {
+	responseBytes, err := c.callAPI(fmt.Sprintf("validator deposit %s %s %s %t", amountWei.String(), utilitySDAmount.String(), numValidators, reloadKeys))
 	if err != nil {
 		return api.NodeDepositResponse{}, fmt.Errorf("could not make validator deposit as er: %w", err)
 	}
@@ -625,12 +625,105 @@ func (c *Client) SetRewardAddress(operatorRewardAddress common.Address) (api.Set
 	if err != nil {
 		return api.SetRewardAddress{}, fmt.Errorf("could not get set-reward-address response: %w", err)
 	}
+
 	var response api.SetRewardAddress
 	if err := json.Unmarshal(responseBytes, &response); err != nil {
 		return api.SetRewardAddress{}, fmt.Errorf("could not decode set-reward-address response: %w", err)
 	}
+
 	if response.Error != "" {
 		return api.SetRewardAddress{}, fmt.Errorf("could not get set-reward-address response: %s", response.Error)
 	}
+
+	return response, nil
+}
+
+func (c *Client) RepaySd(amountWei *big.Int) (api.NodeRepaySDResponse, error) {
+	responseBytes, err := c.callAPI(fmt.Sprintf("node repay-sd %s", amountWei.String()))
+	if err != nil {
+		return api.NodeRepaySDResponse{}, fmt.Errorf("could not repay SD: %w", err)
+	}
+
+	var response api.NodeRepaySDResponse
+	if err := json.Unmarshal(responseBytes, &response); err != nil {
+		return api.NodeRepaySDResponse{}, fmt.Errorf("could not decode repay node SD response: %w", err)
+	}
+
+	if response.Error != "" {
+		return api.NodeRepaySDResponse{}, fmt.Errorf("could not repay SD: %s", response.Error)
+	}
+
+	return response, nil
+}
+
+func (c *Client) CanRepaySd(amountWei *big.Int) (api.CanRepaySDResponse, error) {
+	responseBytes, err := c.callAPI(fmt.Sprintf("node can-repay-sd %s", amountWei.String()))
+	if err != nil {
+		return api.CanRepaySDResponse{}, fmt.Errorf("could not get CanNodeRepaySd SD: %w", err)
+	}
+
+	var response api.CanRepaySDResponse
+	if err := json.Unmarshal(responseBytes, &response); err != nil {
+		return api.CanRepaySDResponse{}, fmt.Errorf("could not decode  CanNodeRepaySd response: %w", err)
+	}
+
+	if response.Error != "" {
+		return api.CanRepaySDResponse{}, fmt.Errorf("could not can-repay SD: %s", response.Error)
+	}
+
+	return response, nil
+}
+
+func (c *Client) NodeUtilizeSd(amountWei *big.Int) (api.NodeUtilitySDResponse, error) {
+	responseBytes, err := c.callAPI(fmt.Sprintf("node utilize-sd %s", amountWei.String()))
+	if err != nil {
+		return api.NodeUtilitySDResponse{}, fmt.Errorf("could not utilize SD: %w", err)
+	}
+
+	var response api.NodeUtilitySDResponse
+	if err := json.Unmarshal(responseBytes, &response); err != nil {
+		return api.NodeUtilitySDResponse{}, fmt.Errorf("could not decode utilize response: %w", err)
+	}
+
+	if response.Error != "" {
+		return api.NodeUtilitySDResponse{}, fmt.Errorf("could not utilize SD: %s", response.Error)
+	}
+
+	return response, nil
+}
+
+func (c *Client) CanNodeUtilizeSd(amountWei *big.Int) (api.CanUtilitySDResponse, error) {
+	responseBytes, err := c.callAPI(fmt.Sprintf("node can-utilize-sd %s", amountWei.String()))
+	if err != nil {
+		return api.CanUtilitySDResponse{}, fmt.Errorf("could not utilize SD: %w", err)
+	}
+
+	var response api.CanUtilitySDResponse
+	if err := json.Unmarshal(responseBytes, &response); err != nil {
+		return api.CanUtilitySDResponse{}, fmt.Errorf("could not decode node SD utilize response: %w", err)
+	}
+
+	if response.Error != "" {
+		return api.CanUtilitySDResponse{}, fmt.Errorf("could not utilize SD: %s", response.Error)
+	}
+
+	return response, nil
+}
+
+func (c *Client) GetSDStatus() (api.GetSdStatusResponse, error) {
+	responseBytes, err := c.callAPI("node get-sd-status")
+	if err != nil {
+		return api.GetSdStatusResponse{}, fmt.Errorf("could not get-sd-status: %w", err)
+	}
+
+	var response api.GetSdStatusResponse
+	if err := json.Unmarshal(responseBytes, &response); err != nil {
+		return api.GetSdStatusResponse{}, fmt.Errorf("could not decode node get SD status response: %w", err)
+	}
+
+	if response.Error != "" {
+		return api.GetSdStatusResponse{}, fmt.Errorf("could not get SD status: %s", response.Error)
+	}
+
 	return response, nil
 }

shared/services/state/network-state.go

@@ -8,6 +8,7 @@ import (
 	"github.com/stader-labs/stader-node/shared/services"
 	"github.com/stader-labs/stader-node/shared/utils/stdr"
 	"github.com/stader-labs/stader-node/stader-lib/contracts"
+	"github.com/stader-labs/stader-node/stader-lib/sdutility"
 	"github.com/urfave/cli"
 
 	"github.com/stader-labs/stader-node/shared/utils/math"
@@ -114,6 +115,9 @@ type MetricDetails struct {
 	OperatorStakedSdInEth float64
 	// done
 	OperatorEthCollateral float64
+
+	// done
+	OperatorSDUtilized float64
 }
 
 type MetricsCache struct {
@@ -153,6 +157,11 @@ func CreateMetricsCache(
 	if err != nil {
 		return nil, err
 	}
+
+	sduAddress, err := services.GetSdUtilityAddress(c)
+	if err != nil {
+		return nil, err
+	}
 	ethxAddress, err := services.GetEthxTokenAddress(c)
 	if err != nil {
 		return nil, err
@@ -212,6 +221,11 @@ func CreateMetricsCache(
 		return nil, err
 	}
 
+	sdu, err := stader.NewSDUtilityPool(ec, sduAddress)
+	if err != nil {
+		return nil, err
+	}
+
 	// Get the execution block for the given slot
 	beaconBlock, exists, err := bc.GetBeaconBlock(fmt.Sprintf("%d", slotNumber))
 	if err != nil {
@@ -449,6 +463,11 @@ func CreateMetricsCache(
 		return nil, err
 	}
 
+	sdUtilized, err := sdutility.GetUtilizerLatestBalance(sdu, nodeAddress, nil)
+	if err != nil {
+		return nil, err
+	}
+
 	minThreshold := math.RoundDown(eth.WeiToEth(permissionlessPoolThreshold.MinThreshold), 2)
 	sdPriceFormatted := math.RoundDown(eth.WeiToEth(sdPrice), 2)
 	collateralRatioInSd := minThreshold * sdPriceFormatted
@@ -497,6 +516,7 @@ func CreateMetricsCache(
 	metricsDetails.UnclaimedSocializingPoolElRewards = math.RoundDown(eth.WeiToEth(rewardClaimData.unclaimedEth), SixDecimalRound)
 	metricsDetails.UnclaimedSocializingPoolSDRewards = math.RoundDown(eth.WeiToEth(rewardClaimData.unclaimedSd), SixDecimalRound)
 
+	metricsDetails.OperatorSDUtilized = math.RoundDown(eth.WeiToEth(sdUtilized), SixDecimalRound)
 	state.StaderNetworkDetails = metricsDetails
 
 	state.logLine("Retrieved Stader Network Details (total time: %s)", time.Since(start))

shared/types/api/node.go

@@ -69,6 +69,7 @@ type CanNodeDepositSdResponse struct {
 	InsufficientBalance      bool           `json:"insufficientBalance"`
 	GasInfo                  stader.GasInfo `json:"gasInfo"`
 }
+
 type NodeDepositSdApproveGasResponse struct {
 	Status  string         `json:"status"`
 	Error   string         `json:"error"`
@@ -97,7 +98,6 @@ type CanNodeDepositResponse struct {
 	InsufficientBalance      bool           `json:"insufficientBalance"`
 	InvalidAmount            bool           `json:"invalidAmount"`
 	DepositPaused            bool           `json:"depositPaused"`
-	NotEnoughSdCollateral    bool           `json:"notEnoughSdCollateral"`
 	MaxValidatorLimitReached bool           `json:"maxValidatorLimitReached"`
 	InputKeyLimitReached     bool           `json:"inputKeyLimitReached"`
 	InputKeyLimit            uint16         `json:"inputKeyLimit"`
@@ -265,11 +265,12 @@ type SendElRewardsResponse struct {
 }
 
 type CanWithdrawSdResponse struct {
-	Status                     string         `json:"status"`
-	Error                      string         `json:"error"`
-	InsufficientSdCollateral   bool           `json:"insufficientSdCollateral"`
-	InsufficientWithdrawableSd bool           `json:"insufficientWithdrawableSd"`
-	GasInfo                    stader.GasInfo `json:"gasInfo"`
+	Status                     string            `json:"status"`
+	Error                      string            `json:"error"`
+	InsufficientSdCollateral   bool              `json:"insufficientSdCollateral"`
+	InsufficientWithdrawableSd bool              `json:"insufficientWithdrawableSd"`
+	SdStatusResponse           *SdStatusResponse `json:"sdStatusResponse"`
+	GasInfo                    stader.GasInfo    `json:"gasInfo"`
 }
 
 type WithdrawSdResponse struct {
@@ -393,10 +394,11 @@ type NodeSignResponse struct {
 }
 
 type CanClaimRewards struct {
-	Status    string         `json:"status"`
-	Error     string         `json:"error"`
-	NoRewards bool           `json:"noRewards"`
-	GasInfo   stader.GasInfo `json:"gasInfo"`
+	Status           string            `json:"status"`
+	Error            string            `json:"error"`
+	NoRewards        bool              `json:"noRewards"`
+	SdStatusResponse *SdStatusResponse `json:"sdStatusResponse"`
+	GasInfo          stader.GasInfo    `json:"gasInfo"`
 }
 
 type ClaimRewards struct {
@@ -406,3 +408,58 @@ type ClaimRewards struct {
 	OperatorRewardAddress  common.Address `json:"operatorRewardAddress"`
 	TxHash                 common.Hash    `json:"txHash"`
 }
+
+type NodeRepaySDResponse struct {
+	Status string      `json:"status"`
+	Error  string      `json:"error"`
+	TxHash common.Hash `json:"txHash"`
+}
+
+type CanRepaySDResponse struct {
+	SdStatusResponse *SdStatusResponse `json:"sdStatusResponse"`
+	Status           string            `json:"status"`
+	Error            string            `json:"error"`
+	GasInfo          stader.GasInfo    `json:"gasInfo"`
+}
+
+type NodeUtilitySDResponse struct {
+	Status string      `json:"status"`
+	Error  string      `json:"error"`
+	TxHash common.Hash `json:"txHash"`
+}
+
+type CanUtilitySDResponse struct {
+	Status  string         `json:"status"`
+	Error   string         `json:"error"`
+	GasInfo stader.GasInfo `json:"gasInfo"`
+}
+
+type GetSdStatusResponse struct {
+	SDStatus *SdStatusResponse `json:"sdStatusResponse"`
+	Status   string            `json:"status"`
+	Error    string            `json:"error"`
+}
+
+type SdStatusResponse struct {
+	SdUtilizerLatestBalance   *big.Int `json:"sdUtilizerLatestBalance"`
+	SdCollateralCurrentAmount *big.Int `json:"sdCollateralCurrentAmount"`
+	SdCollateralRequireAmount *big.Int `json:"sdCollateralRequireAmount"`
+	SdMaxUtilizableAmount     *big.Int `json:"sdMaxUtilizableAmount"`
+	SdMaxCollateralAmount     *big.Int `json:"sdMaxCollateralAmount"`
+	SdBalance                 *big.Int `json:"sdBalance"`
+	PoolAvailableSDBalance    *big.Int `json:"poolAvailableSDBalance"`
+	NotEnoughSdCollateral     bool     `json:"notEnoughSdCollateral"`
+}
+
+type NodeRepayExcessSDResponse struct {
+	Status string      `json:"status"`
+	Error  string      `json:"error"`
+	TxHash common.Hash `json:"txHash"`
+}
+
+type CanRepayExcessSDResponse struct {
+	SdStatusResponse *SdStatusResponse `json:"sdStatusResponse"`
+	Status           string            `json:"status"`
+	Error            string            `json:"error"`
+	GasInfo          stader.GasInfo    `json:"gasInfo"`
+}

shared/utils/cli/prompt.go

@@ -91,3 +91,11 @@ func ConfirmSecureSession(warning string) bool {
 
 	return true
 }
+
+func PrintError(msg string) {
+	fmt.Printf("%s%s%s\n", colorRed, msg, colorReset)
+}
+
+func PrintWarning(msg string) {
+	fmt.Printf("%s%s%s\n", colorYellow, msg, colorReset)
+}