Rocket Pool

# minipool

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

# Index

# Constants

Settings

const (
    MinipoolAddressBatchSize = 50
    MinipoolDetailsBatchSize = 20
)

# func EstimateSubmitMinipoolWithdrawableGas (opens new window)

func EstimateSubmitMinipoolWithdrawableGas(rp *rocketpool.RocketPool, minipoolAddress common.Address, opts *bind.TransactOpts) (rocketpool.GasInfo, error)

Estimate the gas of SubmitMinipoolWithdrawable

# func GetActiveMinipoolCount (opens new window)

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

Get the number of active minipools in the network

# func GetFinalisedMinipoolCount (opens new window)

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

Get the number of finalised minipools in the network

# func GetMinipoolAddresses (opens new window)

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

Get all minipool addresses

# func GetMinipoolAt (opens new window)

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

Get a minipool address by index

# func GetMinipoolByPubkey (opens new window)

func GetMinipoolByPubkey(rp *rocketpool.RocketPool, pubkey rptypes.ValidatorPubkey, opts *bind.CallOpts) (common.Address, error)

Get a minipool address by validator pubkey

# func GetMinipoolCount (opens new window)

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

Get the minipool count

# func GetMinipoolExists (opens new window)

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

Check whether a minipool exists

# func GetMinipoolPubkey (opens new window)

func GetMinipoolPubkey(rp *rocketpool.RocketPool, minipoolAddress common.Address, opts *bind.CallOpts) (rptypes.ValidatorPubkey, error)

Get a minipool's validator pubkey

# func GetNodeActiveMinipoolCount (opens new window)

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

Get the number of minipools owned by a node that are not finalised

# func GetNodeFinalisedMinipoolCount (opens new window)

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

Get the number of minipools owned by a node that are finalised

# func GetNodeMinipoolAddresses (opens new window)

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

Get a node's minipool addresses

# func GetNodeMinipoolAt (opens new window)

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

Get a node's minipool address by index

# func GetNodeMinipoolCount (opens new window)

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

Get a node's minipool count

# func GetNodeValidatingMinipoolAt (opens new window)

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

Get a node's validating minipool address by index

# func GetNodeValidatingMinipoolCount (opens new window)

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

Get a node's validating minipool count

# func GetNodeValidatingMinipoolPubkeys (opens new window)

func GetNodeValidatingMinipoolPubkeys(rp *rocketpool.RocketPool, nodeAddress common.Address, opts *bind.CallOpts) ([]rptypes.ValidatorPubkey, error)

Get a node's validating minipool pubkeys

# func GetQueueEffectiveCapacity (opens new window)

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

Get the total effective capacity of the minipool queue (used in node demand calculation)

# func GetQueueLength (opens new window)

func GetQueueLength(rp *rocketpool.RocketPool, depositType rptypes.MinipoolDeposit, opts *bind.CallOpts) (uint64, error)

Get the length of a single minipool queue

# func GetQueueNextCapacity (opens new window)

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

Get the capacity of the next minipool in the queue

# func GetQueueTotalCapacity (opens new window)

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

Get the total capacity of the minipool queue

# func GetQueueTotalLength (opens new window)

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

Get the total length of the minipool queue

# func SubmitMinipoolWithdrawable (opens new window)

func SubmitMinipoolWithdrawable(rp *rocketpool.RocketPool, minipoolAddress common.Address, opts *bind.TransactOpts) (common.Hash, error)

Submit a minipool withdrawable event

# type Minipool (opens new window)

Minipool contract

type Minipool struct {
    Address    common.Address
    Contract   *rocketpool.Contract
    RocketPool *rocketpool.RocketPool
}

# func NewMinipool (opens new window)

func NewMinipool(rp *rocketpool.RocketPool, address common.Address) (*Minipool, error)

Create new minipool contract

# func (*Minipool) CalculateNodeShare (opens new window)

func (mp *Minipool) CalculateNodeShare(balance *big.Int, opts *bind.CallOpts) (*big.Int, error)

Given a validator balance, calculates how much belongs to the node taking into consideration rewards and penalties

# func (*Minipool) CalculateUserShare (opens new window)

func (mp *Minipool) CalculateUserShare(balance *big.Int, opts *bind.CallOpts) (*big.Int, error)

Given a validator balance, calculates how much belongs to rETH users taking into consideration rewards and penalties

# func (*Minipool) Close (opens new window)

func (mp *Minipool) Close(opts *bind.TransactOpts) (common.Hash, error)

Withdraw node balances from the dissolved minipool and close it

# func (*Minipool) DelegateRollback (opens new window)

func (mp *Minipool) DelegateRollback(opts *bind.TransactOpts) (common.Hash, error)

Rollback to previous delegate contract

# func (*Minipool) DelegateUpgrade (opens new window)

func (mp *Minipool) DelegateUpgrade(opts *bind.TransactOpts) (common.Hash, error)

Upgrade this minipool to the latest network delegate contract

# func (*Minipool) Dissolve (opens new window)

func (mp *Minipool) Dissolve(opts *bind.TransactOpts) (common.Hash, error)

Dissolve the initialized or prelaunch minipool

# func (*Minipool) DistributeBalance (opens new window)

func (mp *Minipool) DistributeBalance(opts *bind.TransactOpts) (common.Hash, error)

Distribute the minipool's ETH balance to the node operator and rETH staking pool. !!! WARNING !!! DO NOT CALL THIS until the minipool's validator has exited from the Beacon Chain and the balance has been deposited into the minipool!

# func (*Minipool) DistributeBalanceAndFinalise (opens new window)

func (mp *Minipool) DistributeBalanceAndFinalise(opts *bind.TransactOpts) (common.Hash, error)

Distribute the minipool's ETH balance to the node operator and rETH staking pool, then finalises the minipool !!! WARNING !!! DO NOT CALL THIS until the minipool's validator has exited from the Beacon Chain and the balance has been deposited into the minipool!

# func (*Minipool) EstimateCloseGas (opens new window)

func (mp *Minipool) EstimateCloseGas(opts *bind.TransactOpts) (rocketpool.GasInfo, error)

Estimate the gas of Close

# func (*Minipool) EstimateDelegateRollbackGas (opens new window)

func (mp *Minipool) EstimateDelegateRollbackGas(opts *bind.TransactOpts) (rocketpool.GasInfo, error)

Estimate the gas of DelegateRollback

# func (*Minipool) EstimateDelegateUpgradeGas (opens new window)

func (mp *Minipool) EstimateDelegateUpgradeGas(opts *bind.TransactOpts) (rocketpool.GasInfo, error)

Estimate the gas of DelegateUpgrade

# func (*Minipool) EstimateDissolveGas (opens new window)

func (mp *Minipool) EstimateDissolveGas(opts *bind.TransactOpts) (rocketpool.GasInfo, error)

Estimate the gas of Dissolve

# func (*Minipool) EstimateDistributeBalanceAndFinaliseGas (opens new window)

func (mp *Minipool) EstimateDistributeBalanceAndFinaliseGas(opts *bind.TransactOpts) (rocketpool.GasInfo, error)

Estimate the gas of DistributeBalanceAndFinalise

# func (*Minipool) EstimateDistributeBalanceGas (opens new window)

func (mp *Minipool) EstimateDistributeBalanceGas(opts *bind.TransactOpts) (rocketpool.GasInfo, error)

Estimate the gas of DistributeBalance

# func (*Minipool) EstimateFinaliseGas (opens new window)

func (mp *Minipool) EstimateFinaliseGas(opts *bind.TransactOpts) (rocketpool.GasInfo, error)

Estimate the gas of Finalise

# func (*Minipool) EstimateRefundGas (opens new window)

func (mp *Minipool) EstimateRefundGas(opts *bind.TransactOpts) (rocketpool.GasInfo, error)

Estimate the gas of Refund

# func (*Minipool) EstimateSetUseLatestDelegateGas (opens new window)

func (mp *Minipool) EstimateSetUseLatestDelegateGas(setting bool, opts *bind.TransactOpts) (rocketpool.GasInfo, error)

Estimate the gas of SetUseLatestDelegate

# func (*Minipool) EstimateStakeGas (opens new window)

func (mp *Minipool) EstimateStakeGas(validatorPubkey rptypes.ValidatorPubkey, validatorSignature rptypes.ValidatorSignature, depositDataRoot common.Hash, opts *bind.TransactOpts) (rocketpool.GasInfo, error)

Estimate the gas of Stake

# func (*Minipool) Finalise (opens new window)

func (mp *Minipool) Finalise(opts *bind.TransactOpts) (common.Hash, error)

Finalise a minipool to get the RPL stake back

# func (*Minipool) GetDelegate (opens new window)

func (mp *Minipool) GetDelegate(opts *bind.CallOpts) (common.Address, error)

Returns the address of the minipool's stored delegate

# func (*Minipool) GetDepositType (opens new window)

func (mp *Minipool) GetDepositType(opts *bind.CallOpts) (rptypes.MinipoolDeposit, error)

Get deposit type

# func (*Minipool) GetEffectiveDelegate (opens new window)

func (mp *Minipool) GetEffectiveDelegate(opts *bind.CallOpts) (common.Address, error)

Returns the delegate which will be used when calling this minipool taking into account useLatestDelegate setting

# func (*Minipool) GetFinalised (opens new window)

func (mp *Minipool) GetFinalised(opts *bind.CallOpts) (bool, error)

# func (*Minipool) GetNodeAddress (opens new window)

func (mp *Minipool) GetNodeAddress(opts *bind.CallOpts) (common.Address, error)

# func (*Minipool) GetNodeDepositAssigned (opens new window)

func (mp *Minipool) GetNodeDepositAssigned(opts *bind.CallOpts) (bool, error)

# func (*Minipool) GetNodeDepositBalance (opens new window)

func (mp *Minipool) GetNodeDepositBalance(opts *bind.CallOpts) (*big.Int, error)

# func (*Minipool) GetNodeDetails (opens new window)

func (mp *Minipool) GetNodeDetails(opts *bind.CallOpts) (NodeDetails, error)

Get node details

# func (*Minipool) GetNodeFee (opens new window)

func (mp *Minipool) GetNodeFee(opts *bind.CallOpts) (float64, error)

# func (*Minipool) GetNodeRefundBalance (opens new window)

func (mp *Minipool) GetNodeRefundBalance(opts *bind.CallOpts) (*big.Int, error)

# func (*Minipool) GetPreviousDelegate (opens new window)

func (mp *Minipool) GetPreviousDelegate(opts *bind.CallOpts) (common.Address, error)

Returns the address of the minipool's previous delegate (or address(0) if not set)

# func (*Minipool) GetStatus (opens new window)

func (mp *Minipool) GetStatus(opts *bind.CallOpts) (rptypes.MinipoolStatus, error)

# func (*Minipool) GetStatusBlock (opens new window)

func (mp *Minipool) GetStatusBlock(opts *bind.CallOpts) (uint64, error)

# func (*Minipool) GetStatusDetails (opens new window)

func (mp *Minipool) GetStatusDetails(opts *bind.CallOpts) (StatusDetails, error)

Get status details

# func (*Minipool) GetStatusTime (opens new window)

func (mp *Minipool) GetStatusTime(opts *bind.CallOpts) (time.Time, error)

# func (*Minipool) GetUseLatestDelegate (opens new window)

func (mp *Minipool) GetUseLatestDelegate(opts *bind.CallOpts) (bool, error)

Getter for useLatestDelegate setting

# func (*Minipool) GetUserDepositAssigned (opens new window)

func (mp *Minipool) GetUserDepositAssigned(opts *bind.CallOpts) (bool, error)

# func (*Minipool) GetUserDepositAssignedTime (opens new window)

func (mp *Minipool) GetUserDepositAssignedTime(opts *bind.CallOpts) (time.Time, error)

# func (*Minipool) GetUserDepositBalance (opens new window)

func (mp *Minipool) GetUserDepositBalance(opts *bind.CallOpts) (*big.Int, error)

# func (*Minipool) GetUserDetails (opens new window)

func (mp *Minipool) GetUserDetails(opts *bind.CallOpts) (UserDetails, error)

Get user deposit details

# func (*Minipool) GetWithdrawalCredentials (opens new window)

func (mp *Minipool) GetWithdrawalCredentials(opts *bind.CallOpts) (common.Hash, error)

Get withdrawal credentials

# func (*Minipool) Refund (opens new window)

func (mp *Minipool) Refund(opts *bind.TransactOpts) (common.Hash, error)

Refund node ETH from the minipool

# func (*Minipool) SetUseLatestDelegate (opens new window)

func (mp *Minipool) SetUseLatestDelegate(setting bool, opts *bind.TransactOpts) (common.Hash, error)

If set to true, will automatically use the latest delegate contract

# func (*Minipool) Stake (opens new window)

func (mp *Minipool) Stake(validatorPubkey rptypes.ValidatorPubkey, validatorSignature rptypes.ValidatorSignature, depositDataRoot common.Hash, opts *bind.TransactOpts) (common.Hash, error)

Progress the prelaunch minipool to staking

# type MinipoolCountsPerStatus (opens new window)

The counts of minipools per status

type MinipoolCountsPerStatus struct {
    Initialized  *big.Int `abi:"initializedCount"`
    Prelaunch    *big.Int `abi:"prelaunchCount"`
    Staking      *big.Int `abi:"stakingCount"`
    Withdrawable *big.Int `abi:"withdrawableCount"`
    Dissolved    *big.Int `abi:"dissolvedCount"`
}

# func GetMinipoolCountPerStatus (opens new window)

func GetMinipoolCountPerStatus(rp *rocketpool.RocketPool, offset, limit uint64, opts *bind.CallOpts) (MinipoolCountsPerStatus, error)

Get the minipool count by status

# type MinipoolDetails (opens new window)

Minipool details

type MinipoolDetails struct {
    Address common.Address          `json:"address"`
    Exists  bool                    `json:"exists"`
    Pubkey  rptypes.ValidatorPubkey `json:"pubkey"`
}

# func GetMinipoolDetails (opens new window)

func GetMinipoolDetails(rp *rocketpool.RocketPool, minipoolAddress common.Address, opts *bind.CallOpts) (MinipoolDetails, error)

Get a minipool's details

# func GetMinipools (opens new window)

func GetMinipools(rp *rocketpool.RocketPool, opts *bind.CallOpts) ([]MinipoolDetails, error)

Get all minipool details

# func GetNodeMinipools (opens new window)

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

Get a node's minipool details

# type NodeDetails (opens new window)

type NodeDetails struct {
    Address         common.Address `json:"address"`
    Fee             float64        `json:"fee"`
    DepositBalance  *big.Int       `json:"depositBalance"`
    RefundBalance   *big.Int       `json:"refundBalance"`
    DepositAssigned bool           `json:"depositAssigned"`
}

# type QueueCapacity (opens new window)

Minipool queue capacity

type QueueCapacity struct {
    Total        *big.Int
    Effective    *big.Int
    NextMinipool *big.Int
}

# func GetQueueCapacity (opens new window)

func GetQueueCapacity(rp *rocketpool.RocketPool, opts *bind.CallOpts) (QueueCapacity, error)

Get minipool queue capacity

# type QueueLengths (opens new window)

Minipool queue lengths

type QueueLengths struct {
    Total        uint64
    FullDeposit  uint64
    HalfDeposit  uint64
    EmptyDeposit uint64
}

# func GetQueueLengths (opens new window)

func GetQueueLengths(rp *rocketpool.RocketPool, opts *bind.CallOpts) (QueueLengths, error)

Get minipool queue lengths

# type StatusDetails (opens new window)

Minipool detail types

type StatusDetails struct {
    Status      rptypes.MinipoolStatus `json:"status"`
    StatusBlock uint64                 `json:"statusBlock"`
    StatusTime  time.Time              `json:"statusTime"`
}

# type UserDetails (opens new window)

type UserDetails struct {
    DepositBalance      *big.Int  `json:"depositBalance"`
    DepositAssigned     bool      `json:"depositAssigned"`
    DepositAssignedTime time.Time `json:"depositAssignedTime"`
}

← network →