Rocket Pool

# protocol

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

# Index

# Constants

Config

const AuctionSettingsContractName = "rocketDAOProtocolSettingsAuction"

Config

const DepositSettingsContractName = "rocketDAOProtocolSettingsDeposit"

Config

const InflationSettingsContractName = "rocketDAOProtocolSettingsInflation"

Config

const MinipoolSettingsContractName = "rocketDAOProtocolSettingsMinipool"

Config

const NetworkSettingsContractName = "rocketDAOProtocolSettingsNetwork"

Config

const NodeSettingsContractName = "rocketDAOProtocolSettingsNode"

Config

const RewardsSettingsContractName = "rocketDAOProtocolSettingsRewards"

# func BootstrapAssignDepositsEnabled (opens new window)

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

# func BootstrapBidOnLotEnabled (opens new window)

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

# func BootstrapCreateLotEnabled (opens new window)

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

# func BootstrapDepositEnabled (opens new window)

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

# func BootstrapInflationIntervalRate (opens new window)

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

# func BootstrapInflationStartTime (opens new window)

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

# func BootstrapLotDuration (opens new window)

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

# func BootstrapLotMaximumEthValue (opens new window)

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

# func BootstrapLotMinimumEthValue (opens new window)

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

# func BootstrapLotReservePriceRatio (opens new window)

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

# func BootstrapLotStartingPriceRatio (opens new window)

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

# func BootstrapMaximumDepositAssignments (opens new window)

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

# func BootstrapMaximumDepositPoolSize (opens new window)

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

# func BootstrapMaximumNodeFee (opens new window)

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

# func BootstrapMaximumPerMinipoolStake (opens new window)

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

# func BootstrapMinimumDeposit (opens new window)

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

# func BootstrapMinimumNodeFee (opens new window)

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

# func BootstrapMinimumPerMinipoolStake (opens new window)

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

# func BootstrapMinipoolLaunchTimeout (opens new window)

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

# func BootstrapMinipoolSubmitWithdrawableEnabled (opens new window)

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

# func BootstrapNodeConsensusThreshold (opens new window)

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

# func BootstrapNodeDepositEnabled (opens new window)

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

# func BootstrapNodeFeeDemandRange (opens new window)

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

# func BootstrapNodeRegistrationEnabled (opens new window)

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

# func BootstrapRewardsClaimIntervalTime (opens new window)

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

# func BootstrapSubmitBalancesEnabled (opens new window)

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

# func BootstrapSubmitBalancesFrequency (opens new window)

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

# func BootstrapSubmitPricesEnabled (opens new window)

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

# func BootstrapSubmitPricesFrequency (opens new window)

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

# func BootstrapTargetNodeFee (opens new window)

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

# func BootstrapTargetRethCollateralRate (opens new window)

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

# func GetAssignDepositsEnabled (opens new window)

func GetAssignDepositsEnabled(rp *rocketpool.RocketPool, opts *bind.CallOpts) (bool, error)

Deposit assignments currently enabled

# func GetBidOnLotEnabled (opens new window)

func GetBidOnLotEnabled(rp *rocketpool.RocketPool, opts *bind.CallOpts) (bool, error)

Lot bidding currently enabled

# func GetCreateLotEnabled (opens new window)

func GetCreateLotEnabled(rp *rocketpool.RocketPool, opts *bind.CallOpts) (bool, error)

Lot creation currently enabled

# func GetDepositEnabled (opens new window)

func GetDepositEnabled(rp *rocketpool.RocketPool, opts *bind.CallOpts) (bool, error)

Deposits currently enabled

# func GetInflationIntervalRate (opens new window)

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

RPL inflation rate per interval

# func GetInflationStartTime (opens new window)

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

RPL inflation start time

# func GetLotDuration (opens new window)

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

The lot duration in blocks

# func GetLotMaximumEthValue (opens new window)

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

The maximum lot size in ETH value

# func GetLotMinimumEthValue (opens new window)

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

The minimum lot size in ETH value

# func GetLotReservePriceRatio (opens new window)

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

The reserve price relative to current ETH price, as a fraction

# func GetLotStartingPriceRatio (opens new window)

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

The starting price relative to current ETH price, as a fraction

# func GetMaximumDepositAssignments (opens new window)

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

Maximum deposit assignments per transaction

# func GetMaximumDepositPoolSize (opens new window)

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

Maximum deposit pool size

# func GetMaximumNodeFee (opens new window)

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

Maximum node commission rate

# func GetMaximumPerMinipoolStake (opens new window)

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

The maximum RPL stake per minipool as a fraction of assigned user ETH

# func GetMinimumDeposit (opens new window)

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

Minimum deposit amount

# func GetMinimumNodeFee (opens new window)

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

Minimum node commission rate

# func GetMinimumPerMinipoolStake (opens new window)

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

The minimum RPL stake per minipool as a fraction of assigned user ETH

# func GetMinipoolEmptyDepositNodeAmount (opens new window)

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

# func GetMinipoolEmptyDepositUserAmount (opens new window)

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

# func GetMinipoolFullDepositNodeAmount (opens new window)

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

Required node deposit amounts

# func GetMinipoolFullDepositUserAmount (opens new window)

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

Required user deposit amounts

# func GetMinipoolHalfDepositNodeAmount (opens new window)

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

# func GetMinipoolHalfDepositUserAmount (opens new window)

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

# func GetMinipoolLaunchBalance (opens new window)

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

Get the minipool launch balance

# func GetMinipoolLaunchTimeout (opens new window)

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

Timeout period in blocks for prelaunch minipools to launch

# func GetMinipoolSubmitWithdrawableEnabled (opens new window)

func GetMinipoolSubmitWithdrawableEnabled(rp *rocketpool.RocketPool, opts *bind.CallOpts) (bool, error)

Minipool withdrawable event submissions currently enabled

# func GetNodeConsensusThreshold (opens new window)

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

The threshold of trusted nodes that must reach consensus on oracle data to commit it

# func GetNodeDepositEnabled (opens new window)

func GetNodeDepositEnabled(rp *rocketpool.RocketPool, opts *bind.CallOpts) (bool, error)

Node deposits currently enabled

# func GetNodeFeeDemandRange (opens new window)

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

The range of node demand values to base fee calculations on

# func GetNodeRegistrationEnabled (opens new window)

func GetNodeRegistrationEnabled(rp *rocketpool.RocketPool, opts *bind.CallOpts) (bool, error)

Node registrations currently enabled

# func GetRewardsClaimIntervalTime (opens new window)

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

Rewards claim interval time

# func GetRewardsClaimerPerc (opens new window)

func GetRewardsClaimerPerc(rp *rocketpool.RocketPool, contractName string, opts *bind.CallOpts) (float64, error)

The claim amount for a claimer as a fraction

# func GetRewardsClaimerPercTimeUpdated (opens new window)

func GetRewardsClaimerPercTimeUpdated(rp *rocketpool.RocketPool, contractName string, opts *bind.CallOpts) (uint64, error)

The time that a claimer's share was last updated

# func GetRewardsClaimersPercTotal (opens new window)

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

The total claim amount for all claimers as a fraction

# func GetSubmitBalancesEnabled (opens new window)

func GetSubmitBalancesEnabled(rp *rocketpool.RocketPool, opts *bind.CallOpts) (bool, error)

Network balance submissions currently enabled

# func GetSubmitBalancesFrequency (opens new window)

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

The frequency in blocks at which network balances should be submitted by trusted nodes

# func GetSubmitPricesEnabled (opens new window)

func GetSubmitPricesEnabled(rp *rocketpool.RocketPool, opts *bind.CallOpts) (bool, error)

Network price submissions currently enabled

# func GetSubmitPricesFrequency (opens new window)

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

The frequency in blocks at which network prices should be submitted by trusted nodes

# func GetTargetNodeFee (opens new window)

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

Target node commission rate

# func GetTargetRethCollateralRate (opens new window)

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

The target collateralization rate for the rETH contract as a fraction

← trustednode →