Rocket Pool

# trustednode

import "github.com/rocket-pool/rocketpool-go/settings/trustednode"

# Index

# Constants

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"
)

Config

const (
    ProposalsSettingsContractName = "rocketDAONodeTrustedSettingsProposals"
    CooldownTimeSettingPath       = "proposal.cooldown.time"
    VoteTimeSettingPath           = "proposal.vote.time"
    VoteDelayTimeSettingPath      = "proposal.vote.delay.time"
    ExecuteTimeSettingPath        = "proposal.execute.time"
    ActionTimeSettingPath         = "proposal.action.time"
)

# func BootstrapChallengeCooldown (opens new window)

func BootstrapChallengeCooldown(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (common.Hash, error)

# func BootstrapChallengeCost (opens new window)

func BootstrapChallengeCost(rp *rocketpool.RocketPool, value *big.Int, opts *bind.TransactOpts) (common.Hash, error)

# func BootstrapChallengeWindow (opens new window)

func BootstrapChallengeWindow(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (common.Hash, error)

# func BootstrapMinipoolUnbondedMax (opens new window)

func BootstrapMinipoolUnbondedMax(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (common.Hash, error)

# func BootstrapMinipoolUnbondedMinFee (opens new window)

func BootstrapMinipoolUnbondedMinFee(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (common.Hash, error)

# func BootstrapProposalActionTime (opens new window)

func BootstrapProposalActionTime(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (common.Hash, error)

# func BootstrapProposalCooldownTime (opens new window)

func BootstrapProposalCooldownTime(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (common.Hash, error)

# func BootstrapProposalExecuteTime (opens new window)

func BootstrapProposalExecuteTime(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (common.Hash, error)

# func BootstrapProposalVoteDelayTime (opens new window)

func BootstrapProposalVoteDelayTime(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (common.Hash, error)

# func BootstrapProposalVoteTime (opens new window)

func BootstrapProposalVoteTime(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (common.Hash, error)

# func BootstrapQuorum (opens new window)

func BootstrapQuorum(rp *rocketpool.RocketPool, value float64, opts *bind.TransactOpts) (common.Hash, error)

# func BootstrapRPLBond (opens new window)

func BootstrapRPLBond(rp *rocketpool.RocketPool, value *big.Int, opts *bind.TransactOpts) (common.Hash, error)

# func EstimateProposeChallengeCooldownGas (opens new window)

func EstimateProposeChallengeCooldownGas(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (rocketpool.GasInfo, error)

# func EstimateProposeChallengeCostGas (opens new window)

func EstimateProposeChallengeCostGas(rp *rocketpool.RocketPool, value *big.Int, opts *bind.TransactOpts) (rocketpool.GasInfo, error)

# func EstimateProposeChallengeWindowGas (opens new window)

func EstimateProposeChallengeWindowGas(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (rocketpool.GasInfo, error)

# func EstimateProposeMinipoolUnbondedMaxGas (opens new window)

func EstimateProposeMinipoolUnbondedMaxGas(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (rocketpool.GasInfo, error)

# func EstimateProposeMinipoolUnbondedMinFeeGas (opens new window)

func EstimateProposeMinipoolUnbondedMinFeeGas(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (rocketpool.GasInfo, error)

# func EstimateProposeProposalActionTimeGas (opens new window)

func EstimateProposeProposalActionTimeGas(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (rocketpool.GasInfo, error)

# func EstimateProposeProposalCooldownTimeGas (opens new window)

func EstimateProposeProposalCooldownTimeGas(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (rocketpool.GasInfo, error)

# func EstimateProposeProposalExecuteTimeGas (opens new window)

func EstimateProposeProposalExecuteTimeGas(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (rocketpool.GasInfo, error)

# func EstimateProposeProposalVoteDelayTimeGas (opens new window)

func EstimateProposeProposalVoteDelayTimeGas(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (rocketpool.GasInfo, error)

# func EstimateProposeProposalVoteTimeGas (opens new window)

func EstimateProposeProposalVoteTimeGas(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (rocketpool.GasInfo, error)

# func EstimateProposeQuorumGas (opens new window)

func EstimateProposeQuorumGas(rp *rocketpool.RocketPool, value float64, opts *bind.TransactOpts) (rocketpool.GasInfo, error)

# func EstimateProposeRPLBondGas (opens new window)

func EstimateProposeRPLBondGas(rp *rocketpool.RocketPool, value *big.Int, opts *bind.TransactOpts) (rocketpool.GasInfo, error)

# func GetChallengeCooldown (opens new window)

func GetChallengeCooldown(rp *rocketpool.RocketPool, opts *bind.CallOpts) (uint64, error)

The period a member must wait for before submitting another challenge, in blocks

# func GetChallengeCost (opens new window)

func GetChallengeCost(rp *rocketpool.RocketPool, opts *bind.CallOpts) (*big.Int, error)

The fee for a non-member to challenge a member, in wei

# func GetChallengeWindow (opens new window)

func GetChallengeWindow(rp *rocketpool.RocketPool, opts *bind.CallOpts) (uint64, error)

The period during which a member can respond to a challenge, in blocks

# func GetMinipoolUnbondedMax (opens new window)

func GetMinipoolUnbondedMax(rp *rocketpool.RocketPool, opts *bind.CallOpts) (uint64, error)

The maximum number of unbonded minipools a member can run

# func GetMinipoolUnbondedMinFee (opens new window)

func GetMinipoolUnbondedMinFee(rp *rocketpool.RocketPool, opts *bind.CallOpts) (uint64, error)

The minimum commission rate before unbonded minipools are allowed

# func GetProposalActionTime (opens new window)

func GetProposalActionTime(rp *rocketpool.RocketPool, opts *bind.CallOpts) (uint64, error)

The period during which an action can be performed on an executed proposal in seconds

# func GetProposalCooldownTime (opens new window)

func GetProposalCooldownTime(rp *rocketpool.RocketPool, opts *bind.CallOpts) (uint64, error)

The cooldown period a member must wait after making a proposal before making another in seconds

# func GetProposalExecuteTime (opens new window)

func GetProposalExecuteTime(rp *rocketpool.RocketPool, opts *bind.CallOpts) (uint64, error)

The period during which a passed proposal can be executed in time

# func GetProposalVoteDelayTime (opens new window)

func GetProposalVoteDelayTime(rp *rocketpool.RocketPool, opts *bind.CallOpts) (uint64, error)

The delay after creation before a proposal can be voted on in seconds

# func GetProposalVoteTime (opens new window)

func GetProposalVoteTime(rp *rocketpool.RocketPool, opts *bind.CallOpts) (uint64, error)

The period a proposal can be voted on for in seconds

# func GetQuorum (opens new window)

func GetQuorum(rp *rocketpool.RocketPool, opts *bind.CallOpts) (float64, error)

Member proposal quorum threshold

# func GetRPLBond (opens new window)

func GetRPLBond(rp *rocketpool.RocketPool, opts *bind.CallOpts) (*big.Int, error)

RPL bond required for a member

# func ProposeChallengeCooldown (opens new window)

func ProposeChallengeCooldown(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (uint64, common.Hash, error)

# func ProposeChallengeCost (opens new window)

func ProposeChallengeCost(rp *rocketpool.RocketPool, value *big.Int, opts *bind.TransactOpts) (uint64, common.Hash, error)

# func ProposeChallengeWindow (opens new window)

func ProposeChallengeWindow(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (uint64, common.Hash, error)

# func ProposeMinipoolUnbondedMax (opens new window)

func ProposeMinipoolUnbondedMax(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (uint64, common.Hash, error)

# func ProposeMinipoolUnbondedMinFee (opens new window)

func ProposeMinipoolUnbondedMinFee(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (uint64, common.Hash, error)

# func ProposeProposalActionTime (opens new window)

func ProposeProposalActionTime(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (uint64, common.Hash, error)

# func ProposeProposalCooldownTime (opens new window)

func ProposeProposalCooldownTime(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (uint64, common.Hash, error)

# func ProposeProposalExecuteTime (opens new window)

func ProposeProposalExecuteTime(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (uint64, common.Hash, error)

# func ProposeProposalVoteDelayTime (opens new window)

func ProposeProposalVoteDelayTime(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (uint64, common.Hash, error)

# func ProposeProposalVoteTime (opens new window)

func ProposeProposalVoteTime(rp *rocketpool.RocketPool, value uint64, opts *bind.TransactOpts) (uint64, common.Hash, error)

# func ProposeQuorum (opens new window)

func ProposeQuorum(rp *rocketpool.RocketPool, value float64, opts *bind.TransactOpts) (uint64, common.Hash, error)

# func ProposeRPLBond (opens new window)

func ProposeRPLBond(rp *rocketpool.RocketPool, value *big.Int, opts *bind.TransactOpts) (uint64, common.Hash, error)

← storage →