Remove unbonded minipool references

bindings/dao/trustednode/dao.go

@@ -21,14 +21,13 @@ const (
 
 // Member details
 type MemberDetails struct {
-	Address                common.Address `json:"address"`
-	Exists                 bool           `json:"exists"`
-	ID                     string         `json:"id"`
-	Url                    string         `json:"url"`
-	JoinedTime             uint64         `json:"joinedTime"`
-	LastProposalTime       uint64         `json:"lastProposalTime"`
-	RPLBondAmount          *big.Int       `json:"rplBondAmount"`
-	UnbondedValidatorCount uint64         `json:"unbondedValidatorCount"`
+	Address          common.Address `json:"address"`
+	Exists           bool           `json:"exists"`
+	ID               string         `json:"id"`
+	Url              string         `json:"url"`
+	JoinedTime       uint64         `json:"joinedTime"`
+	LastProposalTime uint64         `json:"lastProposalTime"`
+	RPLBondAmount    *big.Int       `json:"rplBondAmount"`
 }
 
 // Get all member details
@@ -129,7 +128,6 @@ func GetMemberDetails(rp *rocketpool.RocketPool, memberAddress common.Address, o
 	var joinedTime uint64
 	var lastProposalTime uint64
 	var rplBondAmount *big.Int
-	var unbondedValidatorCount uint64
 
 	// Load data
 	wg.Go(func() error {
@@ -162,11 +160,6 @@ func GetMemberDetails(rp *rocketpool.RocketPool, memberAddress common.Address, o
 		rplBondAmount, err = GetMemberRPLBondAmount(rp, memberAddress, opts)
 		return err
 	})
-	wg.Go(func() error {
-		var err error
-		unbondedValidatorCount, err = GetMemberUnbondedValidatorCount(rp, memberAddress, opts)
-		return err
-	})
 
 	// Wait for data
 	if err := wg.Wait(); err != nil {
@@ -175,14 +168,13 @@ func GetMemberDetails(rp *rocketpool.RocketPool, memberAddress common.Address, o
 
 	// Return
 	return MemberDetails{
-		Address:                memberAddress,
-		Exists:                 exists,
-		ID:                     id,
-		Url:                    url,
-		JoinedTime:             joinedTime,
-		LastProposalTime:       lastProposalTime,
-		RPLBondAmount:          rplBondAmount,
-		UnbondedValidatorCount: unbondedValidatorCount,
+		Address:          memberAddress,
+		Exists:           exists,
+		ID:               id,
+		Url:              url,
+		JoinedTime:       joinedTime,
+		LastProposalTime: lastProposalTime,
+		RPLBondAmount:    rplBondAmount,
 	}, nil
 
 }
@@ -293,17 +285,6 @@ func GetMemberRPLBondAmount(rp *rocketpool.RocketPool, memberAddress common.Addr
 	}
 	return *rplBondAmount, nil
 }
-func GetMemberUnbondedValidatorCount(rp *rocketpool.RocketPool, memberAddress common.Address, opts *bind.CallOpts) (uint64, error) {
-	rocketDAONodeTrusted, err := getRocketDAONodeTrusted(rp, opts)
-	if err != nil {
-		return 0, err
-	}
-	unbondedValidatorCount := new(*big.Int)
-	if err := rocketDAONodeTrusted.Call(opts, unbondedValidatorCount, "getMemberUnbondedValidatorCount", memberAddress); err != nil {
-		return 0, fmt.Errorf("error getting trusted node DAO member %s unbonded validator count: %w", memberAddress.Hex(), err)
-	}
-	return (*unbondedValidatorCount).Uint64(), nil
-}
 
 // Get the time that a proposal for a member was executed at
 func GetMemberInviteProposalExecutedTime(rp *rocketpool.RocketPool, memberAddress common.Address, opts *bind.CallOpts) (uint64, error) {

bindings/settings/trustednode/members.go

@@ -16,14 +16,12 @@ import (
 
 // Config
 const (
-	MembersSettingsContractName       = "rocketDAONodeTrustedSettingsMembers"
-	QuorumSettingPath                 = "members.quorum"
-	RPLBondSettingPath                = "members.rplbond"
-	MinipoolUnbondedMaxSettingPath    = "members.minipool.unbonded.max"
-	MinipoolUnbondedMinFeeSettingPath = "members.minipool.unbonded.min.fee"
-	ChallengeCooldownSettingPath      = "members.challenge.cooldown"
-	ChallengeWindowSettingPath        = "members.challenge.window"
-	ChallengeCostSettingPath          = "members.challenge.cost"
+	MembersSettingsContractName  = "rocketDAONodeTrustedSettingsMembers"
+	QuorumSettingPath            = "members.quorum"
+	RPLBondSettingPath           = "members.rplbond"
+	ChallengeCooldownSettingPath = "members.challenge.cooldown"
+	ChallengeWindowSettingPath   = "members.challenge.window"
+	ChallengeCostSettingPath     = "members.challenge.cost"
 )
 
 // Member proposal quorum threshold
@@ -64,44 +62,6 @@ func EstimateProposeRPLBondGas(rp *rocketpool.RocketPool, value *big.Int, opts *
 	return trustednodedao.EstimateProposeSetUintGas(rp, fmt.Sprintf("set %s", RPLBondSettingPath), MembersSettingsContractName, RPLBondSettingPath, value, opts)
 }
 
-// The maximum number of unbonded minipools a member can run
-func GetMinipoolUnbondedMax(rp *rocketpool.RocketPool, opts *bind.CallOpts) (uint64, error) {
-	membersSettingsContract, err := getMembersSettingsContract(rp, opts)
-	if err != nil {
-		return 0, err
-	}
-	value := new(*big.Int)
-	if err := membersSettingsContract.Call(opts, value, "getMinipoolUnbondedMax"); err != nil {
-		return 0, fmt.Errorf("error getting member unbonded minipool limit: %w", err)
-	}
-	return (*value).Uint64(), nil
-}
-func ProposeMinipoolUnbondedMax(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (uint64, common.Hash, error) {
-	return trustednodedao.ProposeSetUint(rp, fmt.Sprintf("set %s", MinipoolUnbondedMaxSettingPath), MembersSettingsContractName, MinipoolUnbondedMaxSettingPath, big.NewInt(int64(value)), opts)
-}
-func EstimateProposeMinipoolUnbondedMaxGas(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (gaslimit.Limits, error) {
-	return trustednodedao.EstimateProposeSetUintGas(rp, fmt.Sprintf("set %s", MinipoolUnbondedMaxSettingPath), MembersSettingsContractName, MinipoolUnbondedMaxSettingPath, big.NewInt(int64(value)), opts)
-}
-
-// The minimum commission rate before unbonded minipools are allowed
-func GetMinipoolUnbondedMinFee(rp *rocketpool.RocketPool, opts *bind.CallOpts) (uint64, error) {
-	membersSettingsContract, err := getMembersSettingsContract(rp, opts)
-	if err != nil {
-		return 0, err
-	}
-	value := new(*big.Int)
-	if err := membersSettingsContract.Call(opts, value, "getMinipoolUnbondedMinFee"); err != nil {
-		return 0, fmt.Errorf("error getting member unbonded minipool minimum fee: %w", err)
-	}
-	return (*value).Uint64(), nil
-}
-func ProposeMinipoolUnbondedMinFee(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (uint64, common.Hash, error) {
-	return trustednodedao.ProposeSetUint(rp, fmt.Sprintf("set %s", MinipoolUnbondedMinFeeSettingPath), MembersSettingsContractName, MinipoolUnbondedMinFeeSettingPath, big.NewInt(int64(value)), opts)
-}
-func EstimateProposeMinipoolUnbondedMinFeeGas(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (gaslimit.Limits, error) {
-	return trustednodedao.EstimateProposeSetUintGas(rp, fmt.Sprintf("set %s", MinipoolUnbondedMinFeeSettingPath), MembersSettingsContractName, MinipoolUnbondedMinFeeSettingPath, big.NewInt(int64(value)), opts)
-}
-
 // The period a member must wait for before submitting another challenge, in blocks
 func GetChallengeCooldown(rp *rocketpool.RocketPool, opts *bind.CallOpts) (uint64, error) {
 	membersSettingsContract, err := getMembersSettingsContract(rp, opts)

rocketpool-cli/odao/commands.go

@@ -293,27 +293,6 @@ func RegisterCommands(app *cli.Command, name string, aliases []string) {
 
 								},
 							},
-							{
-								Name:      "members-minipool-unbonded-max",
-								Aliases:   []string{"u"},
-								Usage:     "Propose updating the members.minipool.unbonded.max setting - takes a number (e.g 100)",
-								UsageText: "rocketpool odao propose setting members-minipool-unbonded-max value",
-								Action: func(ctx context.Context, c *cli.Command) error {
-
-									// Validate args
-									if err := cliutils.ValidateArgCount(c, 1); err != nil {
-										return err
-									}
-									unbondedMinipoolMax, err := cliutils.ValidateUint("maximum unbonded minipool count", c.Args().Get(0))
-									if err != nil {
-										return err
-									}
-
-									// Run
-									return proposeSettingMinipoolUnbondedMax(unbondedMinipoolMax, c.Bool("yes"))
-
-								},
-							},
 							{
 								Name:      "proposal-cooldown",
 								Aliases:   []string{"c"},

rocketpool-cli/odao/get-settings.go

@@ -26,7 +26,6 @@ func getMemberSettings() error {
 	// Log & return
 	fmt.Printf("ODAO Voting Quorum Threshold: %f%%\n", response.Quorum*100)
 	fmt.Printf("Required Member RPL Bond: %f RPL\n", math.WeiToEth(response.RPLBond))
-	fmt.Printf("Max Number of Unbonded Minipools: %d\n", response.MinipoolUnbondedMax)
 	fmt.Printf("Consecutive Challenge Cooldown: %d Blocks\n", response.ChallengeCooldown)
 	fmt.Printf("Challenge Meeting Window: %d Blocks\n", response.ChallengeWindow)
 	fmt.Printf("Cost for Non-members to Challenge Members: %f ETH\n", math.WeiToEth(response.ChallengeCost))

rocketpool-cli/odao/members.go

@@ -39,7 +39,6 @@ func getMembers() error {
 		fmt.Printf("Joined at:            %s\n", cliutils.GetDateTimeString(member.JoinedTime))
 		fmt.Printf("Last proposal:        %s\n", cliutils.GetDateTimeString(member.LastProposalTime))
 		fmt.Printf("RPL bond amount:      %.6f\n", math.RoundDown(math.WeiToEth(member.RPLBondAmount), 6))
-		fmt.Printf("Unbonded minipools:   %d\n", member.UnbondedValidatorCount)
 		fmt.Printf("\n")
 	}
 	return nil

rocketpool-cli/odao/propose-settings.go

@@ -115,58 +115,6 @@ func proposeSettingMembersRplBond(bondAmountEth float64, yes bool) error {
 
 }
 
-func proposeSettingMinipoolUnbondedMax(unbondedMinipoolMax uint64, yes bool) error {
-
-	// Get RP client
-	rp, err := rocketpool.NewClient().WithReady()
-	if err != nil {
-		return err
-	}
-	defer rp.Close()
-
-	// Check if proposal can be made
-	canPropose, err := rp.CanProposeTNDAOSettingMinipoolUnbondedMax(unbondedMinipoolMax)
-	if err != nil {
-		return err
-	}
-	if !canPropose.CanPropose {
-		fmt.Println("Cannot propose setting update:")
-		if canPropose.ProposalCooldownActive {
-			fmt.Println("The node must wait for the proposal cooldown period to pass before making another proposal.")
-		}
-		return nil
-	}
-
-	// Assign max fees
-	err = gas.AssignMaxFeeAndLimit(canPropose.GasLimits, rp, yes)
-	if err != nil {
-		return err
-	}
-
-	// Prompt for confirmation
-	if prompt.Declined(yes, "Are you sure you want to submit this proposal?") {
-		fmt.Println("Cancelled.")
-		return nil
-	}
-
-	// Submit proposal
-	response, err := rp.ProposeTNDAOSettingMinipoolUnbondedMax(unbondedMinipoolMax)
-	if err != nil {
-		return err
-	}
-
-	fmt.Printf("Submitting proposal...\n")
-	cliutils.PrintTransactionHash(rp, response.TxHash)
-	if _, err = rp.WaitForTransaction(response.TxHash); err != nil {
-		return err
-	}
-
-	// Log & return
-	fmt.Printf("Successfully submitted a members.minipool.unbonded.max setting update proposal with ID %d.\n", response.ProposalId)
-	return nil
-
-}
-
 func proposeSettingProposalCooldown(proposalCooldownTimespan string, yes bool) error {
 
 	// Get RP client

rocketpool-cli/odao/status.go

@@ -26,7 +26,7 @@ func getStatus() error {
 
 	// Membership status
 	if status.IsMember {
-		fmt.Println("The node is a member of the oracle DAO - it can create unbonded minipools, vote on DAO proposals and perform watchtower duties.")
+		fmt.Println("The node is a member of the oracle DAO - it can vote on DAO proposals and perform watchtower duties.")
 		if status.CanLeave {
 			fmt.Println("The node has an executed proposal to leave - you can leave the oracle DAO with 'rocketpool odao leave'")
 		}

rocketpool/api/odao/get-settings.go

@@ -32,11 +32,6 @@ func getMemberSettings(c *cli.Command) (*api.GetTNDAOMemberSettingsResponse, err
 		return nil, fmt.Errorf("Error getting RPL Bond: %w", err)
 	}
 
-	minipoolUnbondedMax, err := trustednode.GetMinipoolUnbondedMax(rp, nil)
-	if err != nil {
-		return nil, fmt.Errorf("Error getting minipool unbonded max: %w", err)
-	}
-
 	challengeCooldown, err := trustednode.GetChallengeCooldown(rp, nil)
 	if err != nil {
 		return nil, fmt.Errorf("Error getting challenge cooldown: %w", err)
@@ -54,7 +49,6 @@ func getMemberSettings(c *cli.Command) (*api.GetTNDAOMemberSettingsResponse, err
 
 	response.Quorum = quorum
 	response.RPLBond = rplBond
-	response.MinipoolUnbondedMax = minipoolUnbondedMax
 	response.ChallengeCooldown = challengeCooldown
 	response.ChallengeWindow = challengeWindow
 	response.ChallengeCost = challengeCost

rocketpool/api/odao/propose-settings.go

@@ -165,69 +165,6 @@ func proposeSettingMembersRplBond(c *cli.Command, bondAmountWei *big.Int, opts *
 
 }
 
-func canProposeSettingMinipoolUnbondedMax(c *cli.Command, unbondedMinipoolMax uint64) (*api.CanProposeTNDAOSettingResponse, error) {
-
-	// Get services
-	if err := services.RequireNodeTrusted(c); err != nil {
-		return nil, err
-	}
-	w, err := services.GetWallet(c)
-	if err != nil {
-		return nil, err
-	}
-	rp, err := services.GetRocketPool(c)
-	if err != nil {
-		return nil, err
-	}
-
-	response, err := canProposeSetting(c, w, rp)
-	if err != nil {
-		return nil, err
-	}
-
-	// Get gas estimate
-	opts, err := w.GetNodeAccountTransactor()
-	if err != nil {
-		return nil, err
-	}
-
-	gasLimits, err := trustednode.EstimateProposeMinipoolUnbondedMaxGas(rp, unbondedMinipoolMax, opts)
-	if err != nil {
-		return nil, err
-	}
-
-	response.GasLimits = gasLimits
-	return response, nil
-
-}
-
-func proposeSettingMinipoolUnbondedMax(c *cli.Command, unbondedMinipoolMax uint64, opts *bind.TransactOpts) (*api.ProposeTNDAOSettingMinipoolUnbondedMaxResponse, error) {
-
-	// Get services
-	if err := services.RequireNodeTrusted(c); err != nil {
-		return nil, err
-	}
-	rp, err := services.GetRocketPool(c)
-	if err != nil {
-		return nil, err
-	}
-
-	// Response
-	response := api.ProposeTNDAOSettingMinipoolUnbondedMaxResponse{}
-
-	// Submit proposal
-	proposalId, hash, err := trustednode.ProposeMinipoolUnbondedMax(rp, unbondedMinipoolMax, opts)
-	if err != nil {
-		return nil, err
-	}
-	response.ProposalId = proposalId
-	response.TxHash = hash
-
-	// Return response
-	return &response, nil
-
-}
-
 func canProposeSettingProposalCooldown(c *cli.Command, proposalCooldownTimespan uint64) (*api.CanProposeTNDAOSettingResponse, error) {
 
 	// Get services

rocketpool/api/odao/routes.go

@@ -324,31 +324,6 @@ func RegisterRoutes(mux *http.ServeMux, c *cli.Command) {
 		response.WriteResponse(w, resp, err)
 	})
 
-	mux.HandleFunc("/api/odao/can-propose-members-minipool-unbonded-max", func(w http.ResponseWriter, r *http.Request) {
-		m, err := parseUint64(r, "max")
-		if err != nil {
-			response.WriteErrorResponse(w, err)
-			return
-		}
-		resp, err := canProposeSettingMinipoolUnbondedMax(c, m)
-		response.WriteResponse(w, resp, err)
-	})
-
-	mux.HandleFunc("/api/odao/propose-members-minipool-unbonded-max", func(w http.ResponseWriter, r *http.Request) {
-		m, err := parseUint64(r, "max")
-		if err != nil {
-			response.WriteErrorResponse(w, err)
-			return
-		}
-		opts, err := services.GetNodeAccountTransactorFromRequest(c, r)
-		if err != nil {
-			response.WriteErrorResponse(w, err)
-			return
-		}
-		resp, err := proposeSettingMinipoolUnbondedMax(c, m, opts)
-		response.WriteResponse(w, resp, err)
-	})
-
 	mux.HandleFunc("/api/odao/can-propose-proposal-cooldown", func(w http.ResponseWriter, r *http.Request) {
 		val, err := parseUint64(r, "value")
 		if err != nil {