Class: Minipool

Rocket Pool Minipool Manager

Constructors

constructor

• new Minipool(web3, contracts)

Create a new Minipool instance.

Parameters

Name	Type	Description
web3	default	A valid Web3 instance
contracts	Contracts	A Rocket Pool Contract Manager Instance

Defined in

rocketpool/minipool/minipool.ts:27

Accessors

rocketMinipoolManager

• Private get rocketMinipoolManager(): Promise<Contract>

Private accessor use to retrieve the related contract

Returns

Promise<Contract>

a Promise<Contract> with a web3.eth.contract instance of the rocketMinipoolManager contract

Defined in

rocketpool/minipool/minipool.ts:33

---

rocketMinipoolQueue

• Private get rocketMinipoolQueue(): Promise<Contract>

Private accessor use to retrieve the related contract

Returns

Promise<Contract>

a Promise<Contract> with a web3.eth.contract instance of the rocketMinipoolQueue contract

Defined in

rocketpool/minipool/minipool.ts:41

---

rocketMinipoolStatus

• Private get rocketMinipoolStatus(): Promise<Contract>

Private accessor use to retrieve the related contract

Returns

Promise<Contract>

a Promise<Contract> with a web3.eth.contract instance of the rocketMinipoolStatus contract

Defined in

rocketpool/minipool/minipool.ts:49

---

rocketMinipool

• Private get rocketMinipool(): Promise<Contract>

Private accessor use to retrieve the related contract

Returns

Promise<Contract>

a Promise<Contract> with a web3.eth.contract instance of the rocketMinipool contract

Defined in

rocketpool/minipool/minipool.ts:57

Methods

getMinipools

▸ getMinipools(): Promise<MinipoolDetails[]>

Get all minipool details

example using Typescript

const minipools = rp.minipool.getMinipools().then((val: MinipoolDetails[]) => { val };

Returns

Promise<MinipoolDetails[]>

a Promise<MinipoolDetails[]> that resolves to an array of MinipoolDetails (address, exists, pubkey)

Defined in

rocketpool/minipool/minipool.ts:70

---

getMinipoolAddresses

▸ getMinipoolAddresses(): Promise<string[]>

Get all minipool addresses

example using Typescript

const addresses = rp.minipool.getMinipoolAddresses().then((val: string[]) => { val };

Returns

Promise<string[]>

a Promise<string[]> that resolves to an array of minipool addresses as strings

Defined in

rocketpool/minipool/minipool.ts:89

---

getNodeMinipools

▸ getNodeMinipools(nodeAddress): Promise<MinipoolDetails[]>

Get all node's minipool details

params nodeAddress a string representing the node address you which to return details for

example using Typescript

const nodeAddress = "0x24fBeD7Ecd625D3f0FD19a6c9113DEd436172294";
const details = rp.minipool.getNodeMinipools(nodeAddress).then((val: MinipoolDetails[]) => { val };

Parameters

Name	Type
nodeAddress	string

Returns

Promise<MinipoolDetails[]>

a Promise<MinipoolDetails[]> that resolves to an array of MinipoolDetails about a specific node

Defined in

rocketpool/minipool/minipool.ts:110

---

getNodeMinipoolAddresses

▸ getNodeMinipoolAddresses(nodeAddress): Promise<string[]>

Get all node's minipool addresses

params nodeAddress a string representing the node address you which to return details for

example using Typescript

const nodeAddress = "0x24fBeD7Ecd625D3f0FD19a6c9113DEd436172294";
const minipoolAddresses = rp.minipool.getNodeMinipoolAddresses(nodeAddress).then((val: string[]) => { val };

Parameters

Name	Type
nodeAddress	string

Returns

Promise<string[]>

a Promise<string[]> that resolves to an array of strings containing the minipool addresses

Defined in

rocketpool/minipool/minipool.ts:131

---

getMinipoolDetails

▸ getMinipoolDetails(address): Promise<MinipoolDetails>

Get all minipool's details

params nodeAddress a string representing the node address you which to return details for

example using Typescript

const nodeAddress = "0x24fBeD7Ecd625D3f0FD19a6c9113DEd436172294";
const minipoolDetails = rp.minipool.getMinipoolDetails(nodeAddress).then((val: MinipoolDetails) => { val };

Parameters

Name	Type
address	string

Returns

Promise<MinipoolDetails>

a Promise<MinipoolDetails> that resolves to a singular MinipoolDetails with details about the minipool you want to look up

Defined in

rocketpool/minipool/minipool.ts:152

---

getMinipoolCount

▸ getMinipoolCount(): Promise<number>

Get all the total minipool count

example using Typescript

const totalMinipools = rp.minipool.getMinipoolCount().then((val: number) => { val };

Returns

Promise<number>

a Promise<number> that resolves to a number representing the total minipool count

Defined in

rocketpool/minipool/minipool.ts:171

---

getMinipoolAt

▸ getMinipoolAt(index): Promise<string>

Get a minipool address by index

params index a number representing the index of the minipool you wish to lookup

example using Typescript

const index = 5;
const address = rp.minipool.getMinipoolAt(index).then((val: string) => { val };

Parameters

Name	Type
index	number

Returns

Promise<string>

a Promise<string> that resolves to a string representing the minipool address

Defined in

rocketpool/minipool/minipool.ts:190

---

getNodeMinipoolCount

▸ getNodeMinipoolCount(nodeAddress): Promise<number>

Get a node's total minipool count

params nodeAddress a string representing the node address you which to return details for

example using Typescript

const nodeAddress = "0x24fBeD7Ecd625D3f0FD19a6c9113DEd436172294";
const nodeMinipoolCount = rp.minipool.getNodeMinipoolCount(nodeAddress).then((val: number) => { val };

Parameters

Name	Type
nodeAddress	string

Returns

Promise<number>

a Promise<number> that resolves to a number representing the node's total minipool count

Defined in

rocketpool/minipool/minipool.ts:207

---

getStakingMinipoolCount

▸ getStakingMinipoolCount(): Promise<number>

Get the staking minipool count

example using Typescript

const stakingMinipoolCount = rp.minipool.getStakingMinipoolCount().then((val: number) => { val };

Returns

Promise<number>

a Promise<number> that resolves to a number representing the total staking minipool count

Defined in

rocketpool/minipool/minipool.ts:224

---

getNodeStakingMinipoolCount

▸ getNodeStakingMinipoolCount(nodeAddress): Promise<number>

Get the node's staking minipool count

params nodeAddress a string representing the node address you which to return details for

example using Typescript

const nodeAddress = "0x24fBeD7Ecd625D3f0FD19a6c9113DEd436172294";
const nodeStakingMinipoolCount = rp.minipool.getNodeStakingMinipoolCount(nodeAddress).then((val: number) => { val };

Parameters

Name	Type
nodeAddress	string

Returns

Promise<number>

a Promise<number> that resolves to a number representing the node's staking minipool count

Defined in

rocketpool/minipool/minipool.ts:241

---

getNodeActiveMinipoolCount

▸ getNodeActiveMinipoolCount(nodeAddress): Promise<string>

Get the node's active minipool count

params nodeAddress a string representing the node address you which to return details for

example using Typescript

const nodeAddress = "0x24fBeD7Ecd625D3f0FD19a6c9113DEd436172294";
const nodeActiveMinipoolCount = rp.minipool.getNodeActiveMinipoolCount(nodeAddress).then((val: number) => { val };

Parameters

Name	Type
nodeAddress	string

Returns

Promise<string>

a Promise<number> that resolves to a number representing the node's active minipool count

Defined in

rocketpool/minipool/minipool.ts:258

---

getNodeMinipoolAt

▸ getNodeMinipoolAt(nodeAddress, index): Promise<string>

Get the node's minipool address by index

params nodeAddress a string representing the node address you which to return details for

params index a number representing the index of

example using Typescript

const nodeAddress = "0x24fBeD7Ecd625D3f0FD19a6c9113DEd436172294";
const index = 2;
const address = rp.minipool.getNodeMinipoolAt(nodeAddress, index).then((val: string) => { val };

Parameters

Name	Type
nodeAddress	string
index	number

Returns

Promise<string>

a Promise<string> that resolves to a string representing the minipool address at the desired index

Defined in

rocketpool/minipool/minipool.ts:277

---

getMinipoolByPubkey

▸ getMinipoolByPubkey(validatorPubkey): Promise<string>

Get a minipool address by validator pubkey

params validatorPubkey a string representing the validator pub key

example using Typescript

const validatorPubkey = "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003";
const address = rp.minipool.getMinipoolByPubkey(nodeAddress).then((val: string) => { val };

Parameters

Name	Type
validatorPubkey	string

Returns

Promise<string>

a Promise<string> that resolves to a string representing the minipool address at the desired pubkey

Defined in

rocketpool/minipool/minipool.ts:294

---

getMinipoolExists

▸ getMinipoolExists(address): Promise<boolean>

Check whether a minipool exists

params address a string representing the minipool address you to check against

example using Typescript

const address = "0x24fBeD7Ecd625D3f0FD19a6c9113DEd436172294";
const exists = rp.minipool.getMinipoolExists(nodeAddress).then((val: boolean) => { val };

Parameters

Name	Type
address	string

Returns

Promise<boolean>

a Promise<boolean> that resolves to a boolean representing if a minipool exists at the address

Defined in

rocketpool/minipool/minipool.ts:311

---

getMinipoolPubkey

▸ getMinipoolPubkey(address): Promise<string>

Get a minipool's validator pubkey

params address a string representing the minipool address

example using Typescript

const address = "0x24fBeD7Ecd625D3f0FD19a6c9113DEd436172294";
const address = rp.minipool.getMinipoolPubkey(nodeAddress).then((val: string) => { val };

Parameters

Name	Type
address	string

Returns

Promise<string>

a Promise<string> that resolves to a string representing the pubkey for the provided minipool address

Defined in

rocketpool/minipool/minipool.ts:328

---

getMinipoolWithdrawalCredentials

▸ getMinipoolWithdrawalCredentials(address): Promise<string>

Get a minipool's withdrawal credentials

params address a string representing the minipool address

example using Typescript

const address = "0x24fBeD7Ecd625D3f0FD19a6c9113DEd436172294";
const address = rp.minipool.getMinipoolWithdrawalCredentials(nodeAddress).then((val: string) => { val };

Parameters

Name	Type
address	string

Returns

Promise<string>

a Promise<string> that resolves to a string representing the minipool credentials

Defined in

rocketpool/minipool/minipool.ts:345

---

getQueueLength

▸ getQueueLength(depositType): Promise<number>

Get the minipool queue length

params depositType a number representing the deposit type

example using Typescript

const length = rp.minipool.getQueueLength(1).then((val: number) => { val };

Parameters

Name	Type
depositType	number

Returns

Promise<number>

a Promise<number> that resolves to a number representing the minipool queue length

Defined in

rocketpool/minipool/minipool.ts:361

---

getQueueTotalLength

▸ getQueueTotalLength(): Promise<number>

Get the total minipool queue length

example using Typescript

const totalLength = rp.minipool.getQueueTotalLength().then((val: number) => { val };

Returns

Promise<number>

a Promise<number> that resolves to a number representing the total minipool queue length

Defined in

rocketpool/minipool/minipool.ts:376

---

getQueueTotalCapacity

▸ getQueueTotalCapacity(): Promise<string>

Get the total capacity of queued minipools in Wei

example using Typescript

const totalLength = rp.minipool.getQueueTotalCapacity().then((val: string) => { val };

Returns

Promise<string>

a Promise<string> that resolves to a number representing the total capacity of queued minipools in Wei

Defined in

rocketpool/minipool/minipool.ts:393

---

getQueueEffectiveCapacity

▸ getQueueEffectiveCapacity(): Promise<string>

Get the effective capacity of queued minipools in Wei (used in node demand calculations)

example using Typescript

const queueEffectiveCapacity = rp.minipool.getQueueEffectiveCapacity().then((val: string) => { val };

Returns

Promise<string>

a Promise<string> that resolves to a number representing the effective capacity of queued minipools in Wei

Defined in

rocketpool/minipool/minipool.ts:408

---

getQueueNextCapacity

▸ getQueueNextCapacity(): Promise<string>

Get the capacity of the next available minipool in Wei

example using Typescript

const queueNextCapacity = rp.minipool.getQueueNextCapacity().then((val: string) => { val };

Returns

Promise<string>

a Promise<string> that resolves to a number representing the capacity of the next available minipool in Wei

Defined in

rocketpool/minipool/minipool.ts:423

---

getMinipoolNodeRewardAmount

▸ getMinipoolNodeRewardAmount(nodeFee, userDepositBalance, startBalance, endBalance): Promise<string>

Get the node reward amount for a minipool by node fee, user deposit balance, and staking start & end balances

params nodeFee a number representing the node fee

params userBalanceString a string representing the user balance in Wei

params startBalance a string representing the start balance in Wei

params endBalance a sttring representing the end balance in Wei

example using Typescript

const rewardsAmount = rp.minipool.getMinipoolNodeRewardAmount(nodeFee, userDepositBalance, startBalance, endBalance).then((val: string) => { val };

Parameters

Name	Type
nodeFee	number
userDepositBalance	string
startBalance	string
endBalance	string

Returns

Promise<string>

a Promise<string> that resolves to a string representing the minipool node rewards amount in Wei

Defined in

rocketpool/minipool/minipool.ts:442

---

getMinipoolContract

▸ getMinipoolContract(address): Promise<MinipoolContract>

Get a MinipoolContract instance

params address a string representing the address of the minipool

example using Typescript

const address = "0x24fBeD7Ecd625D3f0FD19a6c9113DEd436172294";
const minipoolContract = rp.minipool.getMinipoolContract(address).then((val: MinipoolContract) => { val };

Parameters

Name	Type
address	string

Returns

Promise<MinipoolContract>

a Promise<MinipoolContract> that resolves to a MinipoolContract representing the contract of the minipool

Defined in

rocketpool/minipool/minipool.ts:461

---

getEffectiveDelegate

▸ getEffectiveDelegate(address): Promise<string>

Get the effective delegate

params address a string representing the address of the minipool

example using Typescript

const address = "0x24fBeD7Ecd625D3f0FD19a6c9113DEd436172294";
const effectiveDelegate = rp.minipool.getEffectiveDelegate(address).then((val: string) => { val };

Parameters

Name	Type
address	string

Returns

Promise<string>

a Promise<string> that resolves to the address of the effective delegate

Defined in

rocketpool/minipool/minipool.ts:478

---

submitMinipoolWithdrawable

▸ submitMinipoolWithdrawable(minipoolAddress, options?, onConfirmation?): Promise<TransactionReceipt>

Submit a minipool as withdrawable

example using Typescript

const minipoolAddress = "0x24fBeD7Ecd625D3f0FD19a6c9113DEd436172294";
const trustedNode = "0x24fBeD7Ecd625D3f0FD19a6c9113DEd436172294";
const options = {
		from: trustedNode,
		gas: 1000000
};
const txReceipt = rp.minipool.submitWithdrawable(minipoolAddress, options).then((txReceipt: TransactionReceipt) => { txReceipt };

Parameters

Name	Type	Description
minipoolAddress	string	A string representing the address of the minipool
options?	SendOptions	An optional object of web3.eth.Contract SendOptions
onConfirmation?	ConfirmationHandler	An optional confirmation handler object

Returns

Promise<TransactionReceipt>

a Promise<TransactionReceipt> that resolves to a TransactionReceipt object representing the receipt of the transaction

Defined in

rocketpool/minipool/minipool.ts:502