minipool

type IMinipool interface {
	// Get all of the minipool's details
	QueryAllFields(mc *batch.MultiCaller)

	// Gets the underlying minipool's contract
	GetContract() *core.Contract

	// Gets the common binding for all minipool types
	Common() *MinipoolCommon
}

type MinipoolCommon struct {
	// The address of the minipool contract
	Address common.Address

	// The version of the minipool
	Version uint8

	// The address of the node that owns this minipool
	NodeAddress *core.SimpleField[common.Address]

	// The minipool's status
	Status *core.FormattedUint8Field[types.MinipoolStatus]

	// The block that the minipool's status last changed
	StatusBlock *core.FormattedUint256Field[uint64]

	// The time that the minipool's status last changed
	StatusTime *core.FormattedUint256Field[time.Time]

	// True if the minipool has been finalised
	IsFinalised *core.SimpleField[bool]

	// The minipool's commission rate
	NodeFee *core.FormattedUint256Field[float64]

	// The balance the node has deposited to the minipool
	NodeDepositBalance *core.SimpleField[*big.Int]

	// The amount of ETH ready to be refunded to the node
	NodeRefundBalance *core.SimpleField[*big.Int]

	// True if the node deposit has been assigned to the minipool
	NodeDepositAssigned *core.SimpleField[bool]

	// The balance the pool stakers have deposited to the minipool
	UserDepositBalance *core.SimpleField[*big.Int]

	// True if the pool staker deposits has been assigned to the minipool
	UserDepositAssigned *core.SimpleField[bool]

	// The time at which the pool stakers were assigned to the minipool
	UserDepositAssignedTime *core.FormattedUint256Field[time.Time]

	// True if the "use latest delegate" flag is enabled
	IsUseLatestDelegateEnabled *core.SimpleField[bool]

	// The address of the current delegate the minipool has recorded
	DelegateAddress *core.SimpleField[common.Address]

	// The address of the previous delegate the minipool will use after a rollback
	PreviousDelegateAddress *core.SimpleField[common.Address]

	// The address of the delegate the minipool will use (may be different than DelegateAddress if UseLatestDelegate is enabled)
	EffectiveDelegateAddress *core.SimpleField[common.Address]

	// The minipool's penalty count
	PenaltyCount *core.FormattedUint256Field[uint64]

	// True if a minipool exists (i.e. there is a minipool with this contract address)
	Exists *core.SimpleField[bool]

	// The pubkey of the validator on the Beacon Chain managed by this minipool
	Pubkey *core.SimpleField[beacon.ValidatorPubkey]

	// The minipool's 0x01-based withdrawal credentials
	WithdrawalCredentials *core.SimpleField[common.Hash]

	// True if the minipool's RPL has been slashed
	RplSlashed *core.SimpleField[bool]

	// The minipool's deposit type
	DepositType *core.FormattedUint8Field[types.MinipoolDeposit]

	// The queue position of the minipool (-1 means not in the queue, otherwise 0-indexed)
	QueuePosition *core.FormattedUint256Field[int64]
	// contains filtered or unexported fields
}

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

type MinipoolManager struct {
	// The number of minipools in the Rocket Pool network
	MinipoolCount *core.FormattedUint256Field[uint64]

	// The number of staking minipools in the network
	StakingMinipoolCount *core.FormattedUint256Field[uint64]

	// The number of finalised minipools in the network
	FinalisedMinipoolCount *core.FormattedUint256Field[uint64]

	// The number of active minipools in the network
	ActiveMinipoolCount *core.FormattedUint256Field[uint64]

	// The number of vacant minipools in the network
	VacantMinipoolCount *core.FormattedUint256Field[uint64]

	// The total length of the minipool queue
	TotalQueueLength *core.FormattedUint256Field[uint64]

	// The total capacity of the minipool queue
	TotalQueueCapacity *core.SimpleField[*big.Int]

	// The effective capacity of the minipool queue (used in node demand calculation)
	EffectiveQueueCapacity *core.SimpleField[*big.Int]
	// contains filtered or unexported fields
}

type MinipoolPrestakeEvent struct {
	Pubkey                []byte   `abi:"validatorPubkey"`
	Signature             []byte   `abi:"validatorSignature"`
	DepositDataRoot       [32]byte `abi:"depositDataRoot"`
	Amount                *big.Int `abi:"amount"`
	WithdrawalCredentials []byte   `abi:"withdrawalCredentials"`
	Time                  *big.Int `abi:"time"`
}

type MinipoolV2 struct {
	*MinipoolCommon
}

type MinipoolV3 struct {
	*MinipoolCommon

	// True if this is a vacant minipool (pre-staking solo migration)
	IsVacant *core.SimpleField[bool]

	// The node deposit balance of this minipool before its last bond reduction
	PreMigrationBalance *core.SimpleField[*big.Int]

	// True if the minipool's balance has already been distributed by someone other than the node operator
	HasUserDistributed *core.SimpleField[bool]

	// True if the bond reduction process for the minipool has been cancelled
	IsBondReduceCancelled *core.SimpleField[bool]

	// The time at which the MP owner started the bond reduction process
	ReduceBondTime *core.FormattedUint256Field[time.Time]

	// The amount of ETH the minipool is reducing its bond to
	ReduceBondValue *core.SimpleField[*big.Int]

	// The timestamp at which the bond was last reduced
	LastBondReductionTime *core.FormattedUint256Field[time.Time]

	// The previous bond amount of the minipool prior to its last reduction
	LastBondReductionPrevValue *core.SimpleField[*big.Int]

	// The previous node fee (commission) of the minipool prior to its last reduction
	LastBondReductionPrevNodeFee *core.FormattedUint256Field[float64]
	// contains filtered or unexported fields
}

type PrestakeData struct {
	Pubkey                beacon.ValidatorPubkey    `json:"pubkey"`
	WithdrawalCredentials common.Hash               `json:"withdrawalCredentials"`
	Amount                *big.Int                  `json:"amount"`
	Signature             beacon.ValidatorSignature `json:"signature"`
	DepositDataRoot       common.Hash               `json:"depositDataRoot"`
	Time                  time.Time                 `json:"time"`
}

type QueueDetails struct {
	Position int64
}