Rocket Pool

# node

import "github.com/rocket-pool/rocketpool-go/node"

# Index

# Constants

Settings

const (
    NodeAddressBatchSize = 50
    NodeDetailsBatchSize = 20
)

# func CalculateTotalEffectiveRPLStake (opens new window)

func CalculateTotalEffectiveRPLStake(rp *rocketpool.RocketPool, offset, limit, rplPrice *big.Int, opts *bind.CallOpts) (*big.Int, error)

Calculate total effective RPL stake

# func Deposit (opens new window)

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

Make a node deposit

# func EstimateDepositGas (opens new window)

func EstimateDepositGas(rp *rocketpool.RocketPool, minimumNodeFee float64, opts *bind.TransactOpts) (rocketpool.GasInfo, error)

Estimate the gas of Deposit

# func EstimateRegisterNodeGas (opens new window)

func EstimateRegisterNodeGas(rp *rocketpool.RocketPool, timezoneLocation string, opts *bind.TransactOpts) (rocketpool.GasInfo, error)

Estimate the gas of RegisterNode

# func EstimateSetTimezoneLocationGas (opens new window)

func EstimateSetTimezoneLocationGas(rp *rocketpool.RocketPool, timezoneLocation string, opts *bind.TransactOpts) (rocketpool.GasInfo, error)

Estimate the gas of SetTimezoneLocation

# func EstimateStakeGas (opens new window)

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

Estimate the gas of Stake

# func EstimateWithdrawRPLGas (opens new window)

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

Estimate the gas of WithdrawRPL

# func GetBalancesSubmissions (opens new window)

func GetBalancesSubmissions(rp *rocketpool.RocketPool, nodeAddress common.Address, fromBlock uint64, intervalSize *big.Int) (*[]uint64, error)

Returns an array of block numbers for balances submissions the given trusted node has submitted since fromBlock

# func GetNodeAddresses (opens new window)

func GetNodeAddresses(rp *rocketpool.RocketPool, opts *bind.CallOpts) ([]common.Address, error)

Get all node addresses

# func GetNodeAt (opens new window)

func GetNodeAt(rp *rocketpool.RocketPool, index uint64, opts *bind.CallOpts) (common.Address, error)

Get a node address by index

# func GetNodeCount (opens new window)

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

Get the number of nodes in the network

# func GetNodeEffectiveRPLStake (opens new window)

func GetNodeEffectiveRPLStake(rp *rocketpool.RocketPool, nodeAddress common.Address, opts *bind.CallOpts) (*big.Int, error)

Get a node's effective RPL stake

# func GetNodeExists (opens new window)

func GetNodeExists(rp *rocketpool.RocketPool, nodeAddress common.Address, opts *bind.CallOpts) (bool, error)

Check whether a node exists

# func GetNodeMaximumRPLStake (opens new window)

func GetNodeMaximumRPLStake(rp *rocketpool.RocketPool, nodeAddress common.Address, opts *bind.CallOpts) (*big.Int, error)

Get a node's maximum RPL stake to collateralize their minipools

# func GetNodeMinimumRPLStake (opens new window)

func GetNodeMinimumRPLStake(rp *rocketpool.RocketPool, nodeAddress common.Address, opts *bind.CallOpts) (*big.Int, error)

Get a node's minimum RPL stake to collateralize their minipools

# func GetNodeMinipoolLimit (opens new window)

func GetNodeMinipoolLimit(rp *rocketpool.RocketPool, nodeAddress common.Address, opts *bind.CallOpts) (uint64, error)

Get a node's minipool limit based on RPL stake

# func GetNodeRPLStake (opens new window)

func GetNodeRPLStake(rp *rocketpool.RocketPool, nodeAddress common.Address, opts *bind.CallOpts) (*big.Int, error)

Get a node's RPL stake

# func GetNodeRPLStakedTime (opens new window)

func GetNodeRPLStakedTime(rp *rocketpool.RocketPool, nodeAddress common.Address, opts *bind.CallOpts) (uint64, error)

Get the time a node last staked RPL

# func GetNodeTimezoneLocation (opens new window)

func GetNodeTimezoneLocation(rp *rocketpool.RocketPool, nodeAddress common.Address, opts *bind.CallOpts) (string, error)

Get a node's timezone location

# func GetPricesSubmissions (opens new window)

func GetPricesSubmissions(rp *rocketpool.RocketPool, nodeAddress common.Address, fromBlock uint64, intervalSize *big.Int) (*[]uint64, error)

Returns an array of block numbers for prices submissions the given trusted node has submitted since fromBlock

# func GetTotalEffectiveRPLStake (opens new window)

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

Get the effective RPL staked in the network

# func GetTotalRPLStake (opens new window)

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

Get the total RPL staked in the network

# func RegisterNode (opens new window)

func RegisterNode(rp *rocketpool.RocketPool, timezoneLocation string, opts *bind.TransactOpts) (common.Hash, error)

Register a node

# func SetTimezoneLocation (opens new window)

func SetTimezoneLocation(rp *rocketpool.RocketPool, timezoneLocation string, opts *bind.TransactOpts) (common.Hash, error)

Set a node's timezone location

# func StakeRPL (opens new window)

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

Stake RPL

# func WithdrawRPL (opens new window)

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

Withdraw staked RPL

# type NodeDetails (opens new window)

Node details

type NodeDetails struct {
    Address                  common.Address `json:"address"`
    Exists                   bool           `json:"exists"`
    WithdrawalAddress        common.Address `json:"withdrawalAddress"`
    PendingWithdrawalAddress common.Address `json:"pendingWithdrawalAddress"`
    TimezoneLocation         string         `json:"timezoneLocation"`
}

# func GetNodeDetails (opens new window)

func GetNodeDetails(rp *rocketpool.RocketPool, nodeAddress common.Address, opts *bind.CallOpts) (NodeDetails, error)

Get a node's details

# func GetNodes (opens new window)

func GetNodes(rp *rocketpool.RocketPool, opts *bind.CallOpts) ([]NodeDetails, error)

Get all node details

# type TimezoneCount (opens new window)

Count of nodes belonging to a timezone

type TimezoneCount struct {
    Timezone string   `abi:"timezone"`
    Count    *big.Int `abi:"count"`
}

# func GetNodeCountPerTimezone (opens new window)

func GetNodeCountPerTimezone(rp *rocketpool.RocketPool, offset, limit *big.Int, opts *bind.CallOpts) ([]TimezoneCount, error)

Get a breakdown of the number of nodes per timezone

# type TrustedNodeParticipation (opens new window)

The results of the trusted node participation calculation

type TrustedNodeParticipation struct {
    StartBlock          uint64
    UpdateFrequency     uint64
    UpdateCount         uint64
    Probability         float64
    ExpectedSubmissions float64
    ActualSubmissions   map[common.Address]float64
    Participation       map[common.Address][]bool
}

# func CalculateTrustedNodeBalancesParticipation (opens new window)

func CalculateTrustedNodeBalancesParticipation(rp *rocketpool.RocketPool, intervalSize *big.Int, opts *bind.CallOpts) (*TrustedNodeParticipation, error)

Calculates the participation rate of every trusted node on balance submission since the last block that member count changed

# func CalculateTrustedNodePricesParticipation (opens new window)

func CalculateTrustedNodePricesParticipation(rp *rocketpool.RocketPool, intervalSize *big.Int, opts *bind.CallOpts) (*TrustedNodeParticipation, error)

Calculates the participation rate of every trusted node on price submission since the last block that member count changed

← rewards →