protocol

package
v2.0.0-b1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 29, 2024 License: GPL-3.0 Imports: 19 Imported by: 28

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ChallengeSubmitted 

type ChallengeSubmitted struct {
	ProposalID *big.Int       `json:"proposalId"`
	Challenger common.Address `json:"challenger"`
	Index      *big.Int       `json:"index"`
	Timestamp  time.Time      `json:"timestamp"`
}

Structure of the ChallengeSubmitted event

type IProtocolDaoSetting 

type IProtocolDaoSetting[ProposeType core.CallReturnType] interface {
	eth.IQueryable
	GetContract() rocketpool.ContractName
	GetSettingName() SettingName
	ProposeSet(value ProposeType, blockNumber uint32, treeNodes []types.VotingTreeNode, opts *bind.TransactOpts) (*eth.TransactionInfo, error)
	Bootstrap(value ProposeType, opts *bind.TransactOpts) (*eth.TransactionInfo, error)
}

A general interface for settings, parameterized by the type required for proposals and boostrapping

type ProtocolDaoBoolSetting 

type ProtocolDaoBoolSetting struct {
	*core.SimpleField[bool]
	// contains filtered or unexported fields
}

A simple boolean setting

func (*ProtocolDaoBoolSetting) Bootstrap 

func (s *ProtocolDaoBoolSetting) Bootstrap(value bool, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Bootstraps the setting with a new value

func (*ProtocolDaoBoolSetting) GetContract 

func (s *ProtocolDaoBoolSetting) GetContract() rocketpool.ContractName

Gets the owning contract of this setting

func (*ProtocolDaoBoolSetting) GetSettingName 

func (s *ProtocolDaoBoolSetting) GetSettingName() SettingName

Gets the underlying path for the setting within the contracts

func (*ProtocolDaoBoolSetting) ProposeSet 

func (s *ProtocolDaoBoolSetting) ProposeSet(value bool, blockNumber uint32, treeNodes []types.VotingTreeNode, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Creates a proposal to change the setting

type ProtocolDaoCompoundSetting 

type ProtocolDaoCompoundSetting[DataType core.FormattedUint256Type] struct {
	*core.FormattedUint256Field[DataType]
	// contains filtered or unexported fields
}

A uint256 setting that can be formatted to a more well-defined type

func (*ProtocolDaoCompoundSetting[DataType]) Bootstrap 

func (s *ProtocolDaoCompoundSetting[DataType]) Bootstrap(value *big.Int, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Bootstraps the setting with a new value

func (*ProtocolDaoCompoundSetting[DataType]) GetContract 

func (s *ProtocolDaoCompoundSetting[DataType]) GetContract() rocketpool.ContractName

Gets the owning contract of this setting

func (*ProtocolDaoCompoundSetting[DataType]) GetSettingName 

func (s *ProtocolDaoCompoundSetting[DataType]) GetSettingName() SettingName

Gets the underlying path for the setting within the contracts

func (*ProtocolDaoCompoundSetting[DataType]) ProposeSet 

func (s *ProtocolDaoCompoundSetting[DataType]) ProposeSet(value *big.Int, blockNumber uint32, treeNodes []types.VotingTreeNode, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Creates a proposal to change the setting

type ProtocolDaoManager 

type ProtocolDaoManager struct {
	// Settings for the Protocol DAO
	Settings *ProtocolDaoSettings

	// The time that the RPL rewards percentages were last updated
	LastRewardsPercentagesUpdate *core.FormattedUint256Field[time.Time]

	// Get the total number of Protocol DAO proposals
	ProposalCount *core.FormattedUint256Field[uint64]

	// The depth of a network or node voting tree pollard for each round of challenge / response
	DepthPerRound *core.FormattedUint256Field[uint64]

	// The length of a rewards interval
	IntervalTime *core.FormattedUint256Field[time.Duration]
	// contains filtered or unexported fields
}

Binding for RocketDAOProtocol

func NewProtocolDaoManager 

func NewProtocolDaoManager(rp *rocketpool.RocketPool) (*ProtocolDaoManager, error)

Creates a new ProtocolDaoManager contract binding

func (*ProtocolDaoManager) BootstrapAddress 

func (c *ProtocolDaoManager) BootstrapAddress(contractName rocketpool.ContractName, setting SettingName, value common.Address, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for bootstrapping an address setting

func (*ProtocolDaoManager) BootstrapBool 

func (c *ProtocolDaoManager) BootstrapBool(contractName rocketpool.ContractName, setting SettingName, value bool, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for bootstrapping a bool setting

func (*ProtocolDaoManager) BootstrapClaimer 

func (c *ProtocolDaoManager) BootstrapClaimer(contractName rocketpool.ContractName, amount float64, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for bootstrapping a rewards claimer

func (*ProtocolDaoManager) BootstrapUint 

func (c *ProtocolDaoManager) BootstrapUint(contractName rocketpool.ContractName, setting SettingName, value *big.Int, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for bootstrapping a uint256 setting

func (*ProtocolDaoManager) GetChallengeSubmittedEvents 

func (c *ProtocolDaoManager) GetChallengeSubmittedEvents(proposalIDs []uint64, intervalSize *big.Int, startBlock *big.Int, endBlock *big.Int, verifierAddresses []common.Address, opts *bind.CallOpts) ([]ChallengeSubmitted, error)

Get ChallengeSubmitted event info

func (*ProtocolDaoManager) GetContractExists 

func (c *ProtocolDaoManager) GetContractExists(mc *batch.MultiCaller, out *bool, contractName string)

Check if a recurring spend exists with the given contract name

func (*ProtocolDaoManager) GetNodeOperatorRewardsPercent 

func (c *ProtocolDaoManager) GetNodeOperatorRewardsPercent(mc *batch.MultiCaller, out **big.Int)

Get the allocation of RPL rewards to the node operators

func (*ProtocolDaoManager) GetOracleDaoRewardsPercent 

func (c *ProtocolDaoManager) GetOracleDaoRewardsPercent(mc *batch.MultiCaller, out **big.Int)

Get the allocation of RPL rewards to the Oracle DAO

func (*ProtocolDaoManager) GetProposals 

func (c *ProtocolDaoManager) GetProposals(proposalCount uint64, includeDetails bool, opts *bind.CallOpts) ([]*ProtocolDaoProposal, error)

Get all proposal details

func (*ProtocolDaoManager) GetProtocolDaoRewardsPercent 

func (c *ProtocolDaoManager) GetProtocolDaoRewardsPercent(mc *batch.MultiCaller, out **big.Int)

Get the allocation of RPL rewards to the Protocol DAO

func (*ProtocolDaoManager) GetRewardsPercentages 

func (c *ProtocolDaoManager) GetRewardsPercentages(mc *batch.MultiCaller, out *RplRewardsPercentages)

Get the allocation of RPL rewards to the node operators, Oracle DAO, and the Protocol DAO

func (*ProtocolDaoManager) GetRootSubmittedEvents 

func (c *ProtocolDaoManager) GetRootSubmittedEvents(proposalIDs []uint64, intervalSize *big.Int, startBlock *big.Int, endBlock *big.Int, verifierAddresses []common.Address, opts *bind.CallOpts) ([]RootSubmitted, error)

Get RootSubmitted event info

func (*ProtocolDaoManager) ProposeInviteToSecurityCouncil 

func (c *ProtocolDaoManager) ProposeInviteToSecurityCouncil(message string, id string, address common.Address, blockNumber uint32, treeNodes []types.VotingTreeNode, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for submitting a proposal to invite a member to the security council

func (*ProtocolDaoManager) ProposeKickFromSecurityCouncil 

func (c *ProtocolDaoManager) ProposeKickFromSecurityCouncil(message string, address common.Address, blockNumber uint32, treeNodes []types.VotingTreeNode, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for submitting a proposal to kick a member from the security council

func (*ProtocolDaoManager) ProposeKickMultiFromSecurityCouncil 

func (c *ProtocolDaoManager) ProposeKickMultiFromSecurityCouncil(message string, addresses []common.Address, blockNumber uint32, treeNodes []types.VotingTreeNode, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for submitting a proposal to kick multiple members from the security council

func (*ProtocolDaoManager) ProposeOneTimeTreasurySpend 

func (c *ProtocolDaoManager) ProposeOneTimeTreasurySpend(message, invoiceID string, recipient common.Address, amount *big.Int, blockNumber uint32, treeNodes []types.VotingTreeNode, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for submitting a proposal to spend a portion of the Rocket Pool treasury one time

func (*ProtocolDaoManager) ProposeRecurringTreasurySpend 

func (c *ProtocolDaoManager) ProposeRecurringTreasurySpend(message string, contractName string, recipient common.Address, amountPerPeriod *big.Int, periodLength time.Duration, startTime time.Time, numberOfPeriods uint64, blockNumber uint32, treeNodes []types.VotingTreeNode, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for submitting a proposal to spend a portion of the Rocket Pool treasury in a recurring manner

func (*ProtocolDaoManager) ProposeRecurringTreasurySpendUpdate 

func (c *ProtocolDaoManager) ProposeRecurringTreasurySpendUpdate(message string, contractName string, recipient common.Address, amountPerPeriod *big.Int, periodLength time.Duration, numberOfPeriods uint64, blockNumber uint32, treeNodes []types.VotingTreeNode, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for submitting a proposal to update a recurring Rocket Pool treasury spending plan

func (*ProtocolDaoManager) ProposeReplaceSecurityCouncilMember 

func (c *ProtocolDaoManager) ProposeReplaceSecurityCouncilMember(message string, existingMemberAddress common.Address, newMemberID string, newMemberAddress common.Address, blockNumber uint32, treeNodes []types.VotingTreeNode, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for submitting a proposal to replace a member of the security council with another one in a single TX

func (*ProtocolDaoManager) ProposeSetAddress 

func (c *ProtocolDaoManager) ProposeSetAddress(message string, contractName rocketpool.ContractName, setting SettingName, value common.Address, blockNumber uint32, treeNodes []types.VotingTreeNode, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for submitting a proposal to update an address Protocol DAO setting

func (*ProtocolDaoManager) ProposeSetBool 

func (c *ProtocolDaoManager) ProposeSetBool(message string, contractName rocketpool.ContractName, setting SettingName, value bool, blockNumber uint32, treeNodes []types.VotingTreeNode, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for submitting a proposal to update a bool Protocol DAO setting

func (*ProtocolDaoManager) ProposeSetMulti 

func (c *ProtocolDaoManager) ProposeSetMulti(message string, contractNames []rocketpool.ContractName, settings []SettingName, settingTypes []types.ProposalSettingType, values []any, blockNumber uint32, treeNodes []types.VotingTreeNode, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for submitting a proposal to update multiple Protocol DAO settings at once

func (*ProtocolDaoManager) ProposeSetRewardsPercentages 

func (c *ProtocolDaoManager) ProposeSetRewardsPercentages(message string, odaoPercentage *big.Int, pdaoPercentage *big.Int, nodePercentage *big.Int, blockNumber uint32, treeNodes []types.VotingTreeNode, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for submitting a proposal to update the allocations of RPL rewards

func (*ProtocolDaoManager) ProposeSetUint 

func (c *ProtocolDaoManager) ProposeSetUint(message string, contractName rocketpool.ContractName, setting SettingName, value *big.Int, blockNumber uint32, treeNodes []types.VotingTreeNode, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for submitting a proposal to update a uint Protocol DAO setting

type ProtocolDaoProposal 

type ProtocolDaoProposal struct {
	// The proposal's ID
	ID uint64

	// The address of the node that created the proposal
	ProposerAddress *core.SimpleField[common.Address]

	// The block number that was used as the reference when
	// generating the voting tree for this proposal's pollard
	TargetBlock *core.FormattedUint256Field[uint32]

	// The message provided with the proposal
	Message *core.SimpleField[string]

	// The length of time from proposal creation where challenges can be responded to
	ChallengeWindow *core.FormattedUint256Field[time.Duration]

	// The time when nodes can start voting on the proposal (start of phase 1)
	VotingStartTime *core.FormattedUint256Field[time.Time]

	// The time that marks the end of phase 1 and the start of phase 2
	Phase1EndTime *core.FormattedUint256Field[time.Time]

	// The time that marks the end of phase 2
	Phase2EndTime *core.FormattedUint256Field[time.Time]

	// The time the proposal expires on, where it can no longer be executed if successful
	ExpiryTime *core.FormattedUint256Field[time.Time]

	// The time the proposal was created
	CreatedTime *core.FormattedUint256Field[time.Time]

	// The amount of voting power required for the proposal to be decided (the quorum)
	VotingPowerRequired *core.FormattedUint256Field[float64]

	// The amount of voting power that has voted in favor of the proposal
	VotingPowerFor *core.FormattedUint256Field[float64]

	// The amount of voting power that has voted against the proposal
	VotingPowerAgainst *core.FormattedUint256Field[float64]

	// The amount of voting power that has abstained from voting on the proposal
	VotingPowerAbstained *core.FormattedUint256Field[float64]

	// The amount of voting power that has voted to veto the proposal
	VotingPowerToVeto *core.FormattedUint256Field[float64]

	// Whether or not the proposal has been destroyed
	IsDestroyed *core.SimpleField[bool]

	// Whether or not the proposal has been finalized
	IsFinalized *core.SimpleField[bool]

	// Whether or not the proposal has been executed
	IsExecuted *core.SimpleField[bool]

	// Whether or not the proposal has been vetoed
	IsVetoed *core.SimpleField[bool]

	// The amount of voting power required to veto the proposal
	VetoQuorum *core.FormattedUint256Field[float64]

	// The proposal's payload
	Payload *core.SimpleField[[]byte]

	// The proposal's state
	State *core.FormattedUint8Field[types.ProtocolDaoProposalState]

	// The RPL bond locked by the proposer as part of submitting this proposal
	ProposalBond *core.SimpleField[*big.Int]

	// The RPL bond locked by a challenger as part of submitting a challenge against this proposal
	ChallengeBond *core.SimpleField[*big.Int]

	// The index of the tree node that challenged and not responded to, if this proposal was defeated
	DefeatIndex *core.FormattedUint256Field[uint64]
	// contains filtered or unexported fields
}

Binding for proposals

func NewProtocolDaoProposal 

func NewProtocolDaoProposal(rp *rocketpool.RocketPool, id uint64) (*ProtocolDaoProposal, error)

Creates a new ProtocolDaoProposal contract binding

func (*ProtocolDaoProposal) ClaimBondChallenger 

func (p *ProtocolDaoProposal) ClaimBondChallenger(indices []uint64, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for claiming any RPL bond refunds or rewards for a proposal, as a challenger

func (*ProtocolDaoProposal) ClaimBondProposer 

func (p *ProtocolDaoProposal) ClaimBondProposer(indices []uint64, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for claiming any RPL bond refunds or rewards for a proposal, as the proposer

func (*ProtocolDaoProposal) CreateChallenge 

func (p *ProtocolDaoProposal) CreateChallenge(index uint64, node types.VotingTreeNode, witness []types.VotingTreeNode, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for challenging the proposal at a specific tree node index, providing a Merkle proof of the node as well

func (*ProtocolDaoProposal) Defeat 

func (p *ProtocolDaoProposal) Defeat(index uint64, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for defeaing a proposal if the proposer fails to respond to a challenge within the challenge window, providing the node index that wasn't responded to

func (*ProtocolDaoProposal) Execute 

func (p *ProtocolDaoProposal) Execute(opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for executing a proposal

func (*ProtocolDaoProposal) Finalize 

func (p *ProtocolDaoProposal) Finalize(opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for finalizing a vetoed proposal by burning the proposer's bond

func (*ProtocolDaoProposal) GetAddressVoteDirection 

func (p *ProtocolDaoProposal) GetAddressVoteDirection(mc *batch.MultiCaller, address common.Address) func() types.VoteDirection

Get the option that the address voted on for the proposal, and whether or not it's voted yet

func (*ProtocolDaoProposal) GetChallengeState 

func (p *ProtocolDaoProposal) GetChallengeState(mc *batch.MultiCaller, index uint64) func() types.ChallengeState

Get the state of a challenge on a proposal and tree node index

func (*ProtocolDaoProposal) GetProposalPayloadString 

func (p *ProtocolDaoProposal) GetProposalPayloadString() (string, error)

Get a proposal's payload as a human-readable string

func (*ProtocolDaoProposal) GetTreeNode 

func (p *ProtocolDaoProposal) GetTreeNode(mc *batch.MultiCaller, nodeIndex uint64) func() types.VotingTreeNode

Get the tree node of the proposal's voting tree at the given index

func (*ProtocolDaoProposal) OverrideVote 

func (p *ProtocolDaoProposal) OverrideVote(voteDirection types.VoteDirection, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for overriding a delegate's vote during phase 2

func (*ProtocolDaoProposal) SubmitRoot 

func (p *ProtocolDaoProposal) SubmitRoot(index uint64, treeNodes []types.VotingTreeNode, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for submitting the Merkle root for the proposal at the specific index in response to a challenge

func (*ProtocolDaoProposal) Vote 

func (p *ProtocolDaoProposal) Vote(voteDirection types.VoteDirection, votingPower *big.Int, nodeIndex uint64, witness []types.VotingTreeNode, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Get info for voting on a proposal

type ProtocolDaoSettings 

type ProtocolDaoSettings struct {
	Auction struct {
		IsCreateLotEnabled    *ProtocolDaoBoolSetting
		IsBidOnLotEnabled     *ProtocolDaoBoolSetting
		LotMinimumEthValue    *ProtocolDaoUintSetting
		LotMaximumEthValue    *ProtocolDaoUintSetting
		LotDuration           *ProtocolDaoCompoundSetting[time.Duration]
		LotStartingPriceRatio *ProtocolDaoCompoundSetting[float64]
		LotReservePriceRatio  *ProtocolDaoCompoundSetting[float64]
	}

	Deposit struct {
		IsDepositingEnabled                    *ProtocolDaoBoolSetting
		AreDepositAssignmentsEnabled           *ProtocolDaoBoolSetting
		MinimumDeposit                         *ProtocolDaoUintSetting
		MaximumDepositPoolSize                 *ProtocolDaoUintSetting
		MaximumAssignmentsPerDeposit           *ProtocolDaoCompoundSetting[uint64]
		MaximumSocialisedAssignmentsPerDeposit *ProtocolDaoCompoundSetting[uint64]
		DepositFee                             *ProtocolDaoCompoundSetting[float64]
	}

	Inflation struct {
		IntervalRate *ProtocolDaoCompoundSetting[float64]
		StartTime    *ProtocolDaoCompoundSetting[time.Time]
	}

	Minipool struct {
		IsSubmitWithdrawableEnabled *ProtocolDaoBoolSetting
		LaunchTimeout               *ProtocolDaoCompoundSetting[time.Duration]
		IsBondReductionEnabled      *ProtocolDaoBoolSetting
		MaximumCount                *ProtocolDaoCompoundSetting[uint64]
		UserDistributeWindowStart   *ProtocolDaoCompoundSetting[time.Duration]
		UserDistributeWindowLength  *ProtocolDaoCompoundSetting[time.Duration]
	}

	Network struct {
		OracleDaoConsensusThreshold *ProtocolDaoCompoundSetting[float64]
		NodePenaltyThreshold        *ProtocolDaoCompoundSetting[float64]
		PerPenaltyRate              *ProtocolDaoCompoundSetting[float64]
		IsSubmitBalancesEnabled     *ProtocolDaoBoolSetting
		SubmitBalancesFrequency     *ProtocolDaoCompoundSetting[time.Duration]
		IsSubmitPricesEnabled       *ProtocolDaoBoolSetting
		SubmitPricesFrequency       *ProtocolDaoCompoundSetting[time.Duration]
		MinimumNodeFee              *ProtocolDaoCompoundSetting[float64]
		TargetNodeFee               *ProtocolDaoCompoundSetting[float64]
		MaximumNodeFee              *ProtocolDaoCompoundSetting[float64]
		NodeFeeDemandRange          *ProtocolDaoUintSetting
		TargetRethCollateralRate    *ProtocolDaoCompoundSetting[float64]
		IsSubmitRewardsEnabled      *ProtocolDaoBoolSetting
	}

	Node struct {
		IsRegistrationEnabled              *ProtocolDaoBoolSetting
		IsSmoothingPoolRegistrationEnabled *ProtocolDaoBoolSetting
		IsDepositingEnabled                *ProtocolDaoBoolSetting
		AreVacantMinipoolsEnabled          *ProtocolDaoBoolSetting
		MinimumPerMinipoolStake            *ProtocolDaoCompoundSetting[float64]
		MaximumPerMinipoolStake            *ProtocolDaoCompoundSetting[float64]
	}

	Proposals struct {
		VotePhase1Time      *ProtocolDaoCompoundSetting[time.Duration]
		VotePhase2Time      *ProtocolDaoCompoundSetting[time.Duration]
		VoteDelayTime       *ProtocolDaoCompoundSetting[time.Duration]
		ExecuteTime         *ProtocolDaoCompoundSetting[time.Duration]
		ProposalBond        *ProtocolDaoUintSetting
		ChallengeBond       *ProtocolDaoUintSetting
		ChallengePeriod     *ProtocolDaoCompoundSetting[time.Duration]
		ProposalQuorum      *ProtocolDaoCompoundSetting[float64]
		ProposalVetoQuorum  *ProtocolDaoCompoundSetting[float64]
		ProposalMaxBlockAge *ProtocolDaoCompoundSetting[uint64]
	}

	Rewards struct {
		IntervalPeriods *ProtocolDaoCompoundSetting[uint64]
	}

	Security struct {
		MembersQuorum       *ProtocolDaoCompoundSetting[float64]
		MembersLeaveTime    *ProtocolDaoCompoundSetting[time.Duration]
		ProposalVoteTime    *ProtocolDaoCompoundSetting[time.Duration]
		ProposalExecuteTime *ProtocolDaoCompoundSetting[time.Duration]
		ProposalActionTime  *ProtocolDaoCompoundSetting[time.Duration]
	}
	// contains filtered or unexported fields
}

Binding for Protocol DAO settings

func (*ProtocolDaoSettings) GetSettings 

func (c *ProtocolDaoSettings) GetSettings() map[rocketpool.ContractName]SettingsCategory

Get all of the settings, organized by the type used in proposals and boostraps

type ProtocolDaoUintSetting 

type ProtocolDaoUintSetting struct {
	*core.SimpleField[*big.Int]
	// contains filtered or unexported fields
}

A simple uint setting

func (*ProtocolDaoUintSetting) Bootstrap 

func (s *ProtocolDaoUintSetting) Bootstrap(value *big.Int, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Bootstraps the setting with a new value

func (*ProtocolDaoUintSetting) GetContract 

func (s *ProtocolDaoUintSetting) GetContract() rocketpool.ContractName

Gets the owning contract of this setting

func (*ProtocolDaoUintSetting) GetSettingName 

func (s *ProtocolDaoUintSetting) GetSettingName() SettingName

Gets the underlying path for the setting within the contracts

func (*ProtocolDaoUintSetting) ProposeSet 

func (s *ProtocolDaoUintSetting) ProposeSet(value *big.Int, blockNumber uint32, treeNodes []types.VotingTreeNode, opts *bind.TransactOpts) (*eth.TransactionInfo, error)

Creates a proposal to change the setting

type RootSubmitted 

type RootSubmitted struct {
	ProposalID  *big.Int               `json:"proposalId"`
	Proposer    common.Address         `json:"proposer"`
	BlockNumber uint32                 `json:"blockNumber"`
	Index       *big.Int               `json:"index"`
	Root        types.VotingTreeNode   `json:"root"`
	TreeNodes   []types.VotingTreeNode `json:"treeNodes"`
	Timestamp   time.Time              `json:"timestamp"`
}

Structure of the RootSubmitted event

type RplRewardsPercentages 

type RplRewardsPercentages struct {
	OdaoPercentage *big.Int `abi:"trustedNodePerc"`
	PdaoPercentage *big.Int `abi:"protocolPerc"`
	NodePercentage *big.Int `abi:"nodePerc"`
}

Rewards claimer percents

type SettingName 

type SettingName string
const (
	// Auction
	SettingName_Auction_IsCreateLotEnabled    SettingName = "auction.lot.create.enabled"
	SettingName_Auction_IsBidOnLotEnabled     SettingName = "auction.lot.bidding.enabled"
	SettingName_Auction_LotMinimumEthValue    SettingName = "auction.lot.value.minimum"
	SettingName_Auction_LotMaximumEthValue    SettingName = "auction.lot.value.maximum"
	SettingName_Auction_LotDuration           SettingName = "auction.lot.duration"
	SettingName_Auction_LotStartingPriceRatio SettingName = "auction.price.start"
	SettingName_Auction_LotReservePriceRatio  SettingName = "auction.price.reserve"

	// Deposit
	SettingName_Deposit_IsDepositingEnabled                    SettingName = "deposit.enabled"
	SettingName_Deposit_AreDepositAssignmentsEnabled           SettingName = "deposit.assign.enabled"
	SettingName_Deposit_MinimumDeposit                         SettingName = "deposit.minimum"
	SettingName_Deposit_MaximumDepositPoolSize                 SettingName = "deposit.pool.maximum"
	SettingName_Deposit_MaximumAssignmentsPerDeposit           SettingName = "deposit.assign.maximum"
	SettingName_Deposit_MaximumSocialisedAssignmentsPerDeposit SettingName = "deposit.assign.socialised.maximum"
	SettingName_Deposit_DepositFee                             SettingName = "deposit.fee"

	// Inflation
	SettingName_Inflation_IntervalRate SettingName = "rpl.inflation.interval.rate"
	SettingName_Inflation_StartTime    SettingName = "rpl.inflation.interval.start"

	// Minipool
	SettingName_Minipool_IsSubmitWithdrawableEnabled SettingName = "minipool.submit.withdrawable.enabled"
	SettingName_Minipool_LaunchTimeout               SettingName = "minipool.launch.timeout"
	SettingName_Minipool_IsBondReductionEnabled      SettingName = "minipool.bond.reduction.enabled"
	SettingName_Minipool_MaximumCount                SettingName = "minipool.maximum.count"
	SettingName_Minipool_UserDistributeWindowStart   SettingName = "minipool.user.distribute.window.start"
	SettingName_Minipool_UserDistributeWindowLength  SettingName = "minipool.user.distribute.window.length"

	// Network
	SettingName_Network_OracleDaoConsensusThreshold SettingName = "network.consensus.threshold"
	SettingName_Network_NodePenaltyThreshold        SettingName = "network.penalty.threshold"
	SettingName_Network_PerPenaltyRate              SettingName = "network.penalty.per.rate"
	SettingName_Network_IsSubmitBalancesEnabled     SettingName = "network.submit.balances.enabled"
	SettingName_Network_SubmitBalancesFrequency     SettingName = "network.submit.balances.frequency"
	SettingName_Network_IsSubmitPricesEnabled       SettingName = "network.submit.prices.enabled"
	SettingName_Network_SubmitPricesFrequency       SettingName = "network.submit.prices.frequency"
	SettingName_Network_MinimumNodeFee              SettingName = "network.node.fee.minimum"
	SettingName_Network_TargetNodeFee               SettingName = "network.node.fee.target"
	SettingName_Network_MaximumNodeFee              SettingName = "network.node.fee.maximum"
	SettingName_Network_NodeFeeDemandRange          SettingName = "network.node.fee.demand.range"
	SettingName_Network_TargetRethCollateralRate    SettingName = "network.reth.collateral.target"
	SettingName_Network_IsSubmitRewardsEnabled      SettingName = "network.submit.rewards.enabled"

	// Node
	SettingName_Node_IsRegistrationEnabled              SettingName = "node.registration.enabled"
	SettingName_Node_IsSmoothingPoolRegistrationEnabled SettingName = "node.smoothing.pool.registration.enabled"
	SettingName_Node_IsDepositingEnabled                SettingName = "node.deposit.enabled"
	SettingName_Node_AreVacantMinipoolsEnabled          SettingName = "node.vacant.minipools.enabled"
	SettingName_Node_MinimumPerMinipoolStake            SettingName = "node.per.minipool.stake.minimum"
	SettingName_Node_MaximumPerMinipoolStake            SettingName = "node.per.minipool.stake.maximum"

	// Proposals
	SettingName_Proposals_VotePhase1Time      SettingName = "proposal.vote.phase1.time"
	SettingName_Proposals_VotePhase2Time      SettingName = "proposal.vote.phase2.time"
	SettingName_Proposals_VoteDelayTime       SettingName = "proposal.vote.delay.time"
	SettingName_Proposals_ExecuteTime         SettingName = "proposal.execute.time"
	SettingName_Proposals_ProposalBond        SettingName = "proposal.bond"
	SettingName_Proposals_ChallengeBond       SettingName = "proposal.challenge.bond"
	SettingName_Proposals_ChallengePeriod     SettingName = "proposal.challenge.period"
	SettingName_Proposals_ProposalQuorum      SettingName = "proposal.quorum"
	SettingName_Proposals_ProposalVetoQuorum  SettingName = "proposal.veto.quorum"
	SettingName_Proposals_ProposalMaxBlockAge SettingName = "proposal.max.block.age"

	// Rewards
	SettingName_Rewards_IntervalPeriods SettingName = "rewards.claimsperiods"

	// Security
	SettingName_Security_MembersQuorum       SettingName = "members.quorum"
	SettingName_Security_MembersLeaveTime    SettingName = "members.leave.time"
	SettingName_Security_ProposalVoteTime    SettingName = "proposal.vote.time"
	SettingName_Security_ProposalExecuteTime SettingName = "proposal.execute.time"
	SettingName_Security_ProposalActionTime  SettingName = "proposal.action.time"
)

type SettingsCategory 

type SettingsCategory struct {
	ContractName rocketpool.ContractName
	BoolSettings []IProtocolDaoSetting[bool]
	UintSettings []IProtocolDaoSetting[*big.Int]
}

Wrapper for a settings category, with all of its settings

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.