largeStaking

package

Go to main page

Versions in this module

v0

v0.2.1

Oct 8, 2023

v0.2.0

Sep 21, 2023

Changes in this version

type CLStakingExitInfo

+ Pubkeys [][]byte

type LargeStakingCaller

+ func (_LargeStaking *LargeStakingCaller) LargeOracleContractAddr(opts *bind.CallOpts) (common.Address, error)

type LargeStakingCallerSession

+ func (_LargeStaking *LargeStakingCallerSession) LargeOracleContractAddr() (common.Address, error)

type LargeStakingConsensusOracleChanged

+ LargeOracleContractAddr common.Address

+ OldLargeOracleContractAddr common.Address

+ type LargeStakingElRewardAddressChanged struct

+ ElRewardAddr common.Address

+ OldElRewardAddr common.Address

+ Raw types.Log

+ type LargeStakingElRewardAddressChangedIterator struct

+ Event *LargeStakingElRewardAddressChanged

+ func (it *LargeStakingElRewardAddressChangedIterator) Close() error

+ func (it *LargeStakingElRewardAddressChangedIterator) Error() error

+ func (it *LargeStakingElRewardAddressChangedIterator) Next() bool

type LargeStakingFilterer

+ func (_LargeStaking *LargeStakingFilterer) FilterElRewardAddressChanged(opts *bind.FilterOpts) (*LargeStakingElRewardAddressChangedIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterMaxSlashAmountChanged(opts *bind.FilterOpts) (*LargeStakingMaxSlashAmountChangedIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterMinStakeAmountChanged(opts *bind.FilterOpts) (*LargeStakingMinStakeAmountChangedIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseElRewardAddressChanged(log types.Log) (*LargeStakingElRewardAddressChanged, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseMaxSlashAmountChanged(log types.Log) (*LargeStakingMaxSlashAmountChanged, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseMinStakeAmountChanged(log types.Log) (*LargeStakingMinStakeAmountChanged, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchElRewardAddressChanged(opts *bind.WatchOpts, sink chan<- *LargeStakingElRewardAddressChanged) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchMaxSlashAmountChanged(opts *bind.WatchOpts, sink chan<- *LargeStakingMaxSlashAmountChanged) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchMinStakeAmountChanged(opts *bind.WatchOpts, sink chan<- *LargeStakingMinStakeAmountChanged) (event.Subscription, error)

+ type LargeStakingMaxSlashAmountChanged struct

+ MaxSlashAmount *big.Int

+ OldMaxSlashAmount *big.Int

+ Raw types.Log

+ type LargeStakingMaxSlashAmountChangedIterator struct

+ Event *LargeStakingMaxSlashAmountChanged

+ func (it *LargeStakingMaxSlashAmountChangedIterator) Close() error

+ func (it *LargeStakingMaxSlashAmountChangedIterator) Error() error

+ func (it *LargeStakingMaxSlashAmountChangedIterator) Next() bool

+ type LargeStakingMinStakeAmountChanged struct

+ MinStakeAmount *big.Int

+ OldMinStakeAmount *big.Int

+ Raw types.Log

+ type LargeStakingMinStakeAmountChangedIterator struct

+ Event *LargeStakingMinStakeAmountChanged

+ func (it *LargeStakingMinStakeAmountChangedIterator) Close() error

+ func (it *LargeStakingMinStakeAmountChangedIterator) Error() error

+ func (it *LargeStakingMinStakeAmountChangedIterator) Next() bool

type LargeStakingSession

+ func (_LargeStaking *LargeStakingSession) ChangeElRewardAddress(_stakingId *big.Int, _elRewardAddr common.Address) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingSession) LargeOracleContractAddr() (common.Address, error)

type LargeStakingTransactor

+ func (_LargeStaking *LargeStakingTransactor) ChangeElRewardAddress(opts *bind.TransactOpts, _stakingId *big.Int, _elRewardAddr common.Address) (*types.Transaction, error)

type LargeStakingTransactorSession

+ func (_LargeStaking *LargeStakingTransactorSession) ChangeElRewardAddress(_stakingId *big.Int, _elRewardAddr common.Address) (*types.Transaction, error)

v0.2.0-rc7

Sep 4, 2023

v0.2.0-rc6

Sep 1, 2023

v0.2.0-rc5

Aug 31, 2023

v0.2.0-rc3

Aug 25, 2023

v0.2.0-rc2

Aug 25, 2023

v0.2.0-rc1

Aug 18, 2023

v0.1.2

Aug 25, 2023

v0.1.0

Jul 10, 2023

Changes in this version

+ var LargeStakingABI = LargeStakingMetaData.ABI

+ var LargeStakingMetaData = &bind.MetaData

+ type CLStakingExitInfo struct

+ Pubkey []byte

+ StakingId *big.Int

+ type CLStakingSlashInfo struct

+ Pubkey []byte

+ SlashAmount *big.Int

+ StakingId *big.Int

+ type LargeStaking struct

+ func NewLargeStaking(address common.Address, backend bind.ContractBackend) (*LargeStaking, error)

+ type LargeStakingAdminChanged struct

+ NewAdmin common.Address

+ PreviousAdmin common.Address

+ Raw types.Log

+ type LargeStakingAdminChangedIterator struct

+ Event *LargeStakingAdminChanged

+ func (it *LargeStakingAdminChangedIterator) Close() error

+ func (it *LargeStakingAdminChangedIterator) Error() error

+ func (it *LargeStakingAdminChangedIterator) Next() bool

+ type LargeStakingAppendMigretaStake struct

+ Raw types.Log

+ StakeAmounts *big.Int

+ StakingId *big.Int

+ type LargeStakingAppendMigretaStakeIterator struct

+ Event *LargeStakingAppendMigretaStake

+ func (it *LargeStakingAppendMigretaStakeIterator) Close() error

+ func (it *LargeStakingAppendMigretaStakeIterator) Error() error

+ func (it *LargeStakingAppendMigretaStakeIterator) Next() bool

+ type LargeStakingAppendStake struct

+ Amount *big.Int

+ Raw types.Log

+ StakingId *big.Int

+ type LargeStakingAppendStakeIterator struct

+ Event *LargeStakingAppendStake

+ func (it *LargeStakingAppendStakeIterator) Close() error

+ func (it *LargeStakingAppendStakeIterator) Error() error

+ func (it *LargeStakingAppendStakeIterator) Next() bool

+ type LargeStakingBeaconUpgraded struct

+ Beacon common.Address

+ Raw types.Log

+ type LargeStakingBeaconUpgradedIterator struct

+ Event *LargeStakingBeaconUpgraded

+ func (it *LargeStakingBeaconUpgradedIterator) Close() error

+ func (it *LargeStakingBeaconUpgradedIterator) Error() error

+ func (it *LargeStakingBeaconUpgradedIterator) Next() bool

+ type LargeStakingCaller struct

+ func NewLargeStakingCaller(address common.Address, caller bind.ContractCaller) (*LargeStakingCaller, error)

+ func (_LargeStaking *LargeStakingCaller) ConsensusOracleContractAddr(opts *bind.CallOpts) (common.Address, error)

+ func (_LargeStaking *LargeStakingCaller) Dao(opts *bind.CallOpts) (common.Address, error)

+ func (_LargeStaking *LargeStakingCaller) DaoElCommissionRate(opts *bind.CallOpts) (*big.Int, error)

+ func (_LargeStaking *LargeStakingCaller) DaoPrivateRewards(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingCaller) DaoSharedRewards(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingCaller) DaoVaultAddress(opts *bind.CallOpts) (common.Address, error)

+ func (_LargeStaking *LargeStakingCaller) DepositContract(opts *bind.CallOpts) (common.Address, error)

+ func (_LargeStaking *LargeStakingCaller) ELSharedRewardSettleInfo(opts *bind.CallOpts, arg0 *big.Int) (struct{ ... }, error)

+ func (_LargeStaking *LargeStakingCaller) ElPrivateRewardPool(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error)

+ func (_LargeStaking *LargeStakingCaller) ElRewardFactory(opts *bind.CallOpts) (common.Address, error)

+ func (_LargeStaking *LargeStakingCaller) ElSharedRewardPool(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error)

+ func (_LargeStaking *LargeStakingCaller) GetOperatorValidatorCounts(opts *bind.CallOpts, _operatorId *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingCaller) GetRewardPoolInfo(opts *bind.CallOpts, _stakingId *big.Int) (struct{ ... }, error)

+ func (_LargeStaking *LargeStakingCaller) GetStakingInfoOfOwner(opts *bind.CallOpts, _owner common.Address) ([]LargeStakingStakingInfo, error)

+ func (_LargeStaking *LargeStakingCaller) GetValidatorsOfStakingId(opts *bind.CallOpts, _stakingId *big.Int) ([][]byte, error)

+ func (_LargeStaking *LargeStakingCaller) GetWithdrawCredentials(opts *bind.CallOpts, _withdrawCredentials common.Address) ([32]byte, error)

+ func (_LargeStaking *LargeStakingCaller) LargeStakings(opts *bind.CallOpts, arg0 *big.Int) (struct{ ... }, error)

+ func (_LargeStaking *LargeStakingCaller) MAXSLASHAMOUNT(opts *bind.CallOpts) (*big.Int, error)

+ func (_LargeStaking *LargeStakingCaller) MINSTAKEAMOUNT(opts *bind.CallOpts) (*big.Int, error)

+ func (_LargeStaking *LargeStakingCaller) NodeOperatorRegistryContract(opts *bind.CallOpts) (common.Address, error)

+ func (_LargeStaking *LargeStakingCaller) OperatorPrivateRewards(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingCaller) OperatorSharedRewards(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingCaller) OperatorSlashContract(opts *bind.CallOpts) (common.Address, error)

+ func (_LargeStaking *LargeStakingCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_LargeStaking *LargeStakingCaller) ProxiableUUID(opts *bind.CallOpts) ([32]byte, error)

+ func (_LargeStaking *LargeStakingCaller) Reward(opts *bind.CallOpts, _stakingId *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingCaller) TotalLargeStakingCounts(opts *bind.CallOpts) (*big.Int, error)

+ func (_LargeStaking *LargeStakingCaller) TotalShares(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingCaller) UnclaimedPrivateRewards(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingCaller) UnclaimedSharedRewards(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingCaller) ValidatorInfo(opts *bind.CallOpts, arg0 []byte) (struct{ ... }, error)

+ func (_LargeStaking *LargeStakingCaller) ValuePerShare(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error)

+ type LargeStakingCallerRaw struct

+ Contract *LargeStakingCaller

+ func (_LargeStaking *LargeStakingCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type LargeStakingCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *LargeStakingCaller

+ func (_LargeStaking *LargeStakingCallerSession) ConsensusOracleContractAddr() (common.Address, error)

+ func (_LargeStaking *LargeStakingCallerSession) Dao() (common.Address, error)

+ func (_LargeStaking *LargeStakingCallerSession) DaoElCommissionRate() (*big.Int, error)

+ func (_LargeStaking *LargeStakingCallerSession) DaoPrivateRewards(arg0 *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingCallerSession) DaoSharedRewards(arg0 *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingCallerSession) DaoVaultAddress() (common.Address, error)

+ func (_LargeStaking *LargeStakingCallerSession) DepositContract() (common.Address, error)

+ func (_LargeStaking *LargeStakingCallerSession) ELSharedRewardSettleInfo(arg0 *big.Int) (struct{ ... }, error)

+ func (_LargeStaking *LargeStakingCallerSession) ElPrivateRewardPool(arg0 *big.Int) (common.Address, error)

+ func (_LargeStaking *LargeStakingCallerSession) ElRewardFactory() (common.Address, error)

+ func (_LargeStaking *LargeStakingCallerSession) ElSharedRewardPool(arg0 *big.Int) (common.Address, error)

+ func (_LargeStaking *LargeStakingCallerSession) GetOperatorValidatorCounts(_operatorId *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingCallerSession) GetRewardPoolInfo(_stakingId *big.Int) (struct{ ... }, error)

+ func (_LargeStaking *LargeStakingCallerSession) GetStakingInfoOfOwner(_owner common.Address) ([]LargeStakingStakingInfo, error)

+ func (_LargeStaking *LargeStakingCallerSession) GetValidatorsOfStakingId(_stakingId *big.Int) ([][]byte, error)

+ func (_LargeStaking *LargeStakingCallerSession) GetWithdrawCredentials(_withdrawCredentials common.Address) ([32]byte, error)

+ func (_LargeStaking *LargeStakingCallerSession) LargeStakings(arg0 *big.Int) (struct{ ... }, error)

+ func (_LargeStaking *LargeStakingCallerSession) MAXSLASHAMOUNT() (*big.Int, error)

+ func (_LargeStaking *LargeStakingCallerSession) MINSTAKEAMOUNT() (*big.Int, error)

+ func (_LargeStaking *LargeStakingCallerSession) NodeOperatorRegistryContract() (common.Address, error)

+ func (_LargeStaking *LargeStakingCallerSession) OperatorPrivateRewards(arg0 *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingCallerSession) OperatorSharedRewards(arg0 *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingCallerSession) OperatorSlashContract() (common.Address, error)

+ func (_LargeStaking *LargeStakingCallerSession) Owner() (common.Address, error)

+ func (_LargeStaking *LargeStakingCallerSession) ProxiableUUID() ([32]byte, error)

+ func (_LargeStaking *LargeStakingCallerSession) Reward(_stakingId *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingCallerSession) TotalLargeStakingCounts() (*big.Int, error)

+ func (_LargeStaking *LargeStakingCallerSession) TotalShares(arg0 *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingCallerSession) UnclaimedPrivateRewards(arg0 *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingCallerSession) UnclaimedSharedRewards(arg0 *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingCallerSession) ValidatorInfo(arg0 []byte) (struct{ ... }, error)

+ func (_LargeStaking *LargeStakingCallerSession) ValuePerShare(arg0 *big.Int) (*big.Int, error)

+ type LargeStakingConsensusOracleChanged struct

+ ConsensusOracleContractAddr common.Address

+ OldConsensusOracleContractAddr common.Address

+ Raw types.Log

+ type LargeStakingConsensusOracleChangedIterator struct

+ Event *LargeStakingConsensusOracleChanged

+ func (it *LargeStakingConsensusOracleChangedIterator) Close() error

+ func (it *LargeStakingConsensusOracleChangedIterator) Error() error

+ func (it *LargeStakingConsensusOracleChangedIterator) Next() bool

+ type LargeStakingDaoAddressChanged struct

+ Dao common.Address

+ OldDao common.Address

+ Raw types.Log

+ type LargeStakingDaoAddressChangedIterator struct

+ Event *LargeStakingDaoAddressChanged

+ func (it *LargeStakingDaoAddressChangedIterator) Close() error

+ func (it *LargeStakingDaoAddressChangedIterator) Error() error

+ func (it *LargeStakingDaoAddressChangedIterator) Next() bool

+ type LargeStakingDaoELCommissionRateChanged struct

+ DaoElCommissionRate *big.Int

+ OldDaoElCommissionRate *big.Int

+ Raw types.Log

+ type LargeStakingDaoELCommissionRateChangedIterator struct

+ Event *LargeStakingDaoELCommissionRateChanged

+ func (it *LargeStakingDaoELCommissionRateChangedIterator) Close() error

+ func (it *LargeStakingDaoELCommissionRateChangedIterator) Error() error

+ func (it *LargeStakingDaoELCommissionRateChangedIterator) Next() bool

+ type LargeStakingDaoPrivateRewardClaimed struct

+ DaoRewards *big.Int

+ DaoVaultAddress common.Address

+ Raw types.Log

+ StakingId *big.Int

+ type LargeStakingDaoPrivateRewardClaimedIterator struct

+ Event *LargeStakingDaoPrivateRewardClaimed

+ func (it *LargeStakingDaoPrivateRewardClaimedIterator) Close() error

+ func (it *LargeStakingDaoPrivateRewardClaimedIterator) Error() error

+ func (it *LargeStakingDaoPrivateRewardClaimedIterator) Next() bool

+ type LargeStakingDaoSharedRewardClaimed struct

+ DaoRewards *big.Int

+ DaoVaultAddress common.Address

+ OperatorId *big.Int

+ Raw types.Log

+ type LargeStakingDaoSharedRewardClaimedIterator struct

+ Event *LargeStakingDaoSharedRewardClaimed

+ func (it *LargeStakingDaoSharedRewardClaimedIterator) Close() error

+ func (it *LargeStakingDaoSharedRewardClaimedIterator) Error() error

+ func (it *LargeStakingDaoSharedRewardClaimedIterator) Next() bool

+ type LargeStakingDaoVaultAddressChanged struct

+ DaoVaultAddress common.Address

+ OldDaoVaultAddress common.Address

+ Raw types.Log

+ type LargeStakingDaoVaultAddressChangedIterator struct

+ Event *LargeStakingDaoVaultAddressChanged

+ func (it *LargeStakingDaoVaultAddressChangedIterator) Close() error

+ func (it *LargeStakingDaoVaultAddressChangedIterator) Error() error

+ func (it *LargeStakingDaoVaultAddressChangedIterator) Next() bool

+ type LargeStakingELRewardFactoryChanged struct

+ ElRewardFactory common.Address

+ OldElRewardFactory common.Address

+ Raw types.Log

+ type LargeStakingELRewardFactoryChangedIterator struct

+ Event *LargeStakingELRewardFactoryChanged

+ func (it *LargeStakingELRewardFactoryChangedIterator) Close() error

+ func (it *LargeStakingELRewardFactoryChangedIterator) Error() error

+ func (it *LargeStakingELRewardFactoryChangedIterator) Next() bool

+ type LargeStakingELShareingRewardSettle struct

+ DaoReward *big.Int

+ OperatorId *big.Int

+ OperatorReward *big.Int

+ PoolReward *big.Int

+ Raw types.Log

+ type LargeStakingELShareingRewardSettleIterator struct

+ Event *LargeStakingELShareingRewardSettle

+ func (it *LargeStakingELShareingRewardSettleIterator) Close() error

+ func (it *LargeStakingELShareingRewardSettleIterator) Error() error

+ func (it *LargeStakingELShareingRewardSettleIterator) Next() bool

+ type LargeStakingElPrivateRewardSettle struct

+ DaoReward *big.Int

+ OperatorId *big.Int

+ OperatorReward *big.Int

+ PoolReward *big.Int

+ Raw types.Log

+ StakingId *big.Int

+ type LargeStakingElPrivateRewardSettleIterator struct

+ Event *LargeStakingElPrivateRewardSettle

+ func (it *LargeStakingElPrivateRewardSettleIterator) Close() error

+ func (it *LargeStakingElPrivateRewardSettleIterator) Error() error

+ func (it *LargeStakingElPrivateRewardSettleIterator) Next() bool

+ type LargeStakingFastUnstake struct

+ Raw types.Log

+ StakingId *big.Int

+ UnstakeAmount *big.Int

+ type LargeStakingFastUnstakeIterator struct

+ Event *LargeStakingFastUnstake

+ func (it *LargeStakingFastUnstakeIterator) Close() error

+ func (it *LargeStakingFastUnstakeIterator) Error() error

+ func (it *LargeStakingFastUnstakeIterator) Next() bool

+ type LargeStakingFilterer struct

+ func NewLargeStakingFilterer(address common.Address, filterer bind.ContractFilterer) (*LargeStakingFilterer, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*LargeStakingAdminChangedIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterAppendMigretaStake(opts *bind.FilterOpts) (*LargeStakingAppendMigretaStakeIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterAppendStake(opts *bind.FilterOpts) (*LargeStakingAppendStakeIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*LargeStakingBeaconUpgradedIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterConsensusOracleChanged(opts *bind.FilterOpts) (*LargeStakingConsensusOracleChangedIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterDaoAddressChanged(opts *bind.FilterOpts) (*LargeStakingDaoAddressChangedIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterDaoELCommissionRateChanged(opts *bind.FilterOpts) (*LargeStakingDaoELCommissionRateChangedIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterDaoPrivateRewardClaimed(opts *bind.FilterOpts) (*LargeStakingDaoPrivateRewardClaimedIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterDaoSharedRewardClaimed(opts *bind.FilterOpts) (*LargeStakingDaoSharedRewardClaimedIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterDaoVaultAddressChanged(opts *bind.FilterOpts) (*LargeStakingDaoVaultAddressChangedIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterELRewardFactoryChanged(opts *bind.FilterOpts) (*LargeStakingELRewardFactoryChangedIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterELShareingRewardSettle(opts *bind.FilterOpts) (*LargeStakingELShareingRewardSettleIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterElPrivateRewardSettle(opts *bind.FilterOpts) (*LargeStakingElPrivateRewardSettleIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterFastUnstake(opts *bind.FilterOpts) (*LargeStakingFastUnstakeIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterInitialized(opts *bind.FilterOpts) (*LargeStakingInitializedIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterLargeStake(opts *bind.FilterOpts) (*LargeStakingLargeStakeIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterLargeStakingSlash(opts *bind.FilterOpts) (*LargeStakingLargeStakingSlashIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterLargeUnstake(opts *bind.FilterOpts) (*LargeStakingLargeUnstakeIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterMigretaStake(opts *bind.FilterOpts) (*LargeStakingMigretaStakeIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterMinStakeAmountChange(opts *bind.FilterOpts) (*LargeStakingMinStakeAmountChangeIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterNodeOperatorsRegistryChanged(opts *bind.FilterOpts) (*LargeStakingNodeOperatorsRegistryChangedIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterOperatorPrivateRewardClaimed(opts *bind.FilterOpts) (*LargeStakingOperatorPrivateRewardClaimedIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterOperatorRewardClaimed(opts *bind.FilterOpts) (*LargeStakingOperatorRewardClaimedIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterOperatorSharedRewardClaimed(opts *bind.FilterOpts) (*LargeStakingOperatorSharedRewardClaimedIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterOperatorSlashChanged(opts *bind.FilterOpts) (*LargeStakingOperatorSlashChangedIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*LargeStakingOwnershipTransferredIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterSharedRewardPoolStart(opts *bind.FilterOpts) (*LargeStakingSharedRewardPoolStartIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*LargeStakingUpgradedIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterUserRewardClaimed(opts *bind.FilterOpts) (*LargeStakingUserRewardClaimedIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterValidatorExitReport(opts *bind.FilterOpts) (*LargeStakingValidatorExitReportIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) FilterValidatorRegistered(opts *bind.FilterOpts) (*LargeStakingValidatorRegisteredIterator, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseAdminChanged(log types.Log) (*LargeStakingAdminChanged, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseAppendMigretaStake(log types.Log) (*LargeStakingAppendMigretaStake, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseAppendStake(log types.Log) (*LargeStakingAppendStake, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseBeaconUpgraded(log types.Log) (*LargeStakingBeaconUpgraded, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseConsensusOracleChanged(log types.Log) (*LargeStakingConsensusOracleChanged, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseDaoAddressChanged(log types.Log) (*LargeStakingDaoAddressChanged, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseDaoELCommissionRateChanged(log types.Log) (*LargeStakingDaoELCommissionRateChanged, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseDaoPrivateRewardClaimed(log types.Log) (*LargeStakingDaoPrivateRewardClaimed, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseDaoSharedRewardClaimed(log types.Log) (*LargeStakingDaoSharedRewardClaimed, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseDaoVaultAddressChanged(log types.Log) (*LargeStakingDaoVaultAddressChanged, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseELRewardFactoryChanged(log types.Log) (*LargeStakingELRewardFactoryChanged, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseELShareingRewardSettle(log types.Log) (*LargeStakingELShareingRewardSettle, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseElPrivateRewardSettle(log types.Log) (*LargeStakingElPrivateRewardSettle, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseFastUnstake(log types.Log) (*LargeStakingFastUnstake, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseInitialized(log types.Log) (*LargeStakingInitialized, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseLargeStake(log types.Log) (*LargeStakingLargeStake, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseLargeStakingSlash(log types.Log) (*LargeStakingLargeStakingSlash, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseLargeUnstake(log types.Log) (*LargeStakingLargeUnstake, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseMigretaStake(log types.Log) (*LargeStakingMigretaStake, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseMinStakeAmountChange(log types.Log) (*LargeStakingMinStakeAmountChange, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseNodeOperatorsRegistryChanged(log types.Log) (*LargeStakingNodeOperatorsRegistryChanged, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseOperatorPrivateRewardClaimed(log types.Log) (*LargeStakingOperatorPrivateRewardClaimed, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseOperatorRewardClaimed(log types.Log) (*LargeStakingOperatorRewardClaimed, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseOperatorSharedRewardClaimed(log types.Log) (*LargeStakingOperatorSharedRewardClaimed, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseOperatorSlashChanged(log types.Log) (*LargeStakingOperatorSlashChanged, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseOwnershipTransferred(log types.Log) (*LargeStakingOwnershipTransferred, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseSharedRewardPoolStart(log types.Log) (*LargeStakingSharedRewardPoolStart, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseUpgraded(log types.Log) (*LargeStakingUpgraded, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseUserRewardClaimed(log types.Log) (*LargeStakingUserRewardClaimed, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseValidatorExitReport(log types.Log) (*LargeStakingValidatorExitReport, error)

+ func (_LargeStaking *LargeStakingFilterer) ParseValidatorRegistered(log types.Log) (*LargeStakingValidatorRegistered, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *LargeStakingAdminChanged) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchAppendMigretaStake(opts *bind.WatchOpts, sink chan<- *LargeStakingAppendMigretaStake) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchAppendStake(opts *bind.WatchOpts, sink chan<- *LargeStakingAppendStake) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *LargeStakingBeaconUpgraded, ...) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchConsensusOracleChanged(opts *bind.WatchOpts, sink chan<- *LargeStakingConsensusOracleChanged) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchDaoAddressChanged(opts *bind.WatchOpts, sink chan<- *LargeStakingDaoAddressChanged) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchDaoELCommissionRateChanged(opts *bind.WatchOpts, sink chan<- *LargeStakingDaoELCommissionRateChanged) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchDaoPrivateRewardClaimed(opts *bind.WatchOpts, sink chan<- *LargeStakingDaoPrivateRewardClaimed) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchDaoSharedRewardClaimed(opts *bind.WatchOpts, sink chan<- *LargeStakingDaoSharedRewardClaimed) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchDaoVaultAddressChanged(opts *bind.WatchOpts, sink chan<- *LargeStakingDaoVaultAddressChanged) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchELRewardFactoryChanged(opts *bind.WatchOpts, sink chan<- *LargeStakingELRewardFactoryChanged) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchELShareingRewardSettle(opts *bind.WatchOpts, sink chan<- *LargeStakingELShareingRewardSettle) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchElPrivateRewardSettle(opts *bind.WatchOpts, sink chan<- *LargeStakingElPrivateRewardSettle) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchFastUnstake(opts *bind.WatchOpts, sink chan<- *LargeStakingFastUnstake) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *LargeStakingInitialized) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchLargeStake(opts *bind.WatchOpts, sink chan<- *LargeStakingLargeStake) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchLargeStakingSlash(opts *bind.WatchOpts, sink chan<- *LargeStakingLargeStakingSlash) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchLargeUnstake(opts *bind.WatchOpts, sink chan<- *LargeStakingLargeUnstake) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchMigretaStake(opts *bind.WatchOpts, sink chan<- *LargeStakingMigretaStake) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchMinStakeAmountChange(opts *bind.WatchOpts, sink chan<- *LargeStakingMinStakeAmountChange) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchNodeOperatorsRegistryChanged(opts *bind.WatchOpts, sink chan<- *LargeStakingNodeOperatorsRegistryChanged) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchOperatorPrivateRewardClaimed(opts *bind.WatchOpts, sink chan<- *LargeStakingOperatorPrivateRewardClaimed) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchOperatorRewardClaimed(opts *bind.WatchOpts, sink chan<- *LargeStakingOperatorRewardClaimed) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchOperatorSharedRewardClaimed(opts *bind.WatchOpts, sink chan<- *LargeStakingOperatorSharedRewardClaimed) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchOperatorSlashChanged(opts *bind.WatchOpts, sink chan<- *LargeStakingOperatorSlashChanged) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *LargeStakingOwnershipTransferred, ...) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchSharedRewardPoolStart(opts *bind.WatchOpts, sink chan<- *LargeStakingSharedRewardPoolStart) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *LargeStakingUpgraded, ...) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchUserRewardClaimed(opts *bind.WatchOpts, sink chan<- *LargeStakingUserRewardClaimed) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchValidatorExitReport(opts *bind.WatchOpts, sink chan<- *LargeStakingValidatorExitReport) (event.Subscription, error)

+ func (_LargeStaking *LargeStakingFilterer) WatchValidatorRegistered(opts *bind.WatchOpts, sink chan<- *LargeStakingValidatorRegistered) (event.Subscription, error)

+ type LargeStakingInitialized struct

+ Raw types.Log

+ Version uint8

+ type LargeStakingInitializedIterator struct

+ Event *LargeStakingInitialized

+ func (it *LargeStakingInitializedIterator) Close() error

+ func (it *LargeStakingInitializedIterator) Error() error

+ func (it *LargeStakingInitializedIterator) Next() bool

+ type LargeStakingLargeStake struct

+ Amount *big.Int

+ CurStakingId *big.Int

+ ElRewardAddr common.Address

+ IsELRewardSharing bool

+ OperatorId *big.Int

+ Owner common.Address

+ Raw types.Log

+ WithdrawCredentials common.Address

+ type LargeStakingLargeStakeIterator struct

+ Event *LargeStakingLargeStake

+ func (it *LargeStakingLargeStakeIterator) Close() error

+ func (it *LargeStakingLargeStakeIterator) Error() error

+ func (it *LargeStakingLargeStakeIterator) Next() bool

+ type LargeStakingLargeStakingSlash struct

+ Amounts *big.Int

+ OperatorIds *big.Int

+ Pubkey []byte

+ Raw types.Log

+ StakingIds *big.Int

+ type LargeStakingLargeStakingSlashIterator struct

+ Event *LargeStakingLargeStakingSlash

+ func (it *LargeStakingLargeStakingSlashIterator) Close() error

+ func (it *LargeStakingLargeStakingSlashIterator) Error() error

+ func (it *LargeStakingLargeStakingSlashIterator) Next() bool

+ type LargeStakingLargeUnstake struct

+ Amount *big.Int

+ Raw types.Log

+ StakingId *big.Int

+ type LargeStakingLargeUnstakeIterator struct

+ Event *LargeStakingLargeUnstake

+ func (it *LargeStakingLargeUnstakeIterator) Close() error

+ func (it *LargeStakingLargeUnstakeIterator) Error() error

+ func (it *LargeStakingLargeUnstakeIterator) Next() bool

+ type LargeStakingMigretaStake struct

+ Amount *big.Int

+ CurStakingId *big.Int

+ ElRewardAddr common.Address

+ IsELRewardSharing bool

+ OperatorId *big.Int

+ Owner common.Address

+ Raw types.Log

+ WithdrawCredentials common.Address

+ type LargeStakingMigretaStakeIterator struct

+ Event *LargeStakingMigretaStake

+ func (it *LargeStakingMigretaStakeIterator) Close() error

+ func (it *LargeStakingMigretaStakeIterator) Error() error

+ func (it *LargeStakingMigretaStakeIterator) Next() bool

+ type LargeStakingMinStakeAmountChange struct

+ MinStakeAmount *big.Int

+ OldMinStakeAmount *big.Int

+ Raw types.Log

+ type LargeStakingMinStakeAmountChangeIterator struct

+ Event *LargeStakingMinStakeAmountChange

+ func (it *LargeStakingMinStakeAmountChangeIterator) Close() error

+ func (it *LargeStakingMinStakeAmountChangeIterator) Error() error

+ func (it *LargeStakingMinStakeAmountChangeIterator) Next() bool

+ type LargeStakingNodeOperatorsRegistryChanged struct

+ NodeOperatorRegistryAddress common.Address

+ OldNodeOperatorRegistryContract common.Address

+ Raw types.Log

+ type LargeStakingNodeOperatorsRegistryChangedIterator struct

+ Event *LargeStakingNodeOperatorsRegistryChanged

+ func (it *LargeStakingNodeOperatorsRegistryChangedIterator) Close() error

+ func (it *LargeStakingNodeOperatorsRegistryChangedIterator) Error() error

+ func (it *LargeStakingNodeOperatorsRegistryChangedIterator) Next() bool

+ type LargeStakingOperatorPrivateRewardClaimed struct

+ OperatorId *big.Int

+ OperatorRewards *big.Int

+ Raw types.Log

+ StakingId *big.Int

+ type LargeStakingOperatorPrivateRewardClaimedIterator struct

+ Event *LargeStakingOperatorPrivateRewardClaimed

+ func (it *LargeStakingOperatorPrivateRewardClaimedIterator) Close() error

+ func (it *LargeStakingOperatorPrivateRewardClaimedIterator) Error() error

+ func (it *LargeStakingOperatorPrivateRewardClaimedIterator) Next() bool

+ type LargeStakingOperatorRewardClaimed struct

+ OperatorId *big.Int

+ Raw types.Log

+ RewardAddresses common.Address

+ RewardAmounts *big.Int

+ type LargeStakingOperatorRewardClaimedIterator struct

+ Event *LargeStakingOperatorRewardClaimed

+ func (it *LargeStakingOperatorRewardClaimedIterator) Close() error

+ func (it *LargeStakingOperatorRewardClaimedIterator) Error() error

+ func (it *LargeStakingOperatorRewardClaimedIterator) Next() bool

+ type LargeStakingOperatorSharedRewardClaimed struct

+ OperatorId *big.Int

+ OperatorRewards *big.Int

+ Raw types.Log

+ type LargeStakingOperatorSharedRewardClaimedIterator struct

+ Event *LargeStakingOperatorSharedRewardClaimed

+ func (it *LargeStakingOperatorSharedRewardClaimedIterator) Close() error

+ func (it *LargeStakingOperatorSharedRewardClaimedIterator) Error() error

+ func (it *LargeStakingOperatorSharedRewardClaimedIterator) Next() bool

+ type LargeStakingOperatorSlashChanged struct

+ OldOperatorSlashContract common.Address

+ OperatorSlashContract common.Address

+ Raw types.Log

+ type LargeStakingOperatorSlashChangedIterator struct

+ Event *LargeStakingOperatorSlashChanged

+ func (it *LargeStakingOperatorSlashChangedIterator) Close() error

+ func (it *LargeStakingOperatorSlashChangedIterator) Error() error

+ func (it *LargeStakingOperatorSlashChangedIterator) Next() bool

+ type LargeStakingOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type LargeStakingOwnershipTransferredIterator struct

+ Event *LargeStakingOwnershipTransferred

+ func (it *LargeStakingOwnershipTransferredIterator) Close() error

+ func (it *LargeStakingOwnershipTransferredIterator) Error() error

+ func (it *LargeStakingOwnershipTransferredIterator) Next() bool

+ type LargeStakingRaw struct

+ Contract *LargeStaking

+ func (_LargeStaking *LargeStakingRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_LargeStaking *LargeStakingRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type LargeStakingSession struct

+ CallOpts bind.CallOpts

+ Contract *LargeStaking

+ TransactOpts bind.TransactOpts

+ func (_LargeStaking *LargeStakingSession) AppendLargeStake(_stakingId *big.Int, _owner common.Address, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingSession) AppendMigrateStake(_stakingId *big.Int, _owner common.Address, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingSession) ClaimRewardsOfDao(_stakingIds []*big.Int) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingSession) ClaimRewardsOfOperator(_operatorId *big.Int, _privatePoolStakingIds []*big.Int) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingSession) ClaimRewardsOfUser(_stakingId *big.Int, rewards *big.Int) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingSession) ConsensusOracleContractAddr() (common.Address, error)

+ func (_LargeStaking *LargeStakingSession) Dao() (common.Address, error)

+ func (_LargeStaking *LargeStakingSession) DaoElCommissionRate() (*big.Int, error)

+ func (_LargeStaking *LargeStakingSession) DaoPrivateRewards(arg0 *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingSession) DaoSharedRewards(arg0 *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingSession) DaoVaultAddress() (common.Address, error)

+ func (_LargeStaking *LargeStakingSession) DepositContract() (common.Address, error)

+ func (_LargeStaking *LargeStakingSession) ELSharedRewardSettleInfo(arg0 *big.Int) (struct{ ... }, error)

+ func (_LargeStaking *LargeStakingSession) ElPrivateRewardPool(arg0 *big.Int) (common.Address, error)

+ func (_LargeStaking *LargeStakingSession) ElRewardFactory() (common.Address, error)

+ func (_LargeStaking *LargeStakingSession) ElSharedRewardPool(arg0 *big.Int) (common.Address, error)

+ func (_LargeStaking *LargeStakingSession) GetOperatorValidatorCounts(_operatorId *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingSession) GetRewardPoolInfo(_stakingId *big.Int) (struct{ ... }, error)

+ func (_LargeStaking *LargeStakingSession) GetStakingInfoOfOwner(_owner common.Address) ([]LargeStakingStakingInfo, error)

+ func (_LargeStaking *LargeStakingSession) GetValidatorsOfStakingId(_stakingId *big.Int) ([][]byte, error)

+ func (_LargeStaking *LargeStakingSession) GetWithdrawCredentials(_withdrawCredentials common.Address) ([32]byte, error)

+ func (_LargeStaking *LargeStakingSession) Initialize(_dao common.Address, _daoVaultAddress common.Address, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingSession) LargeStake(_operatorId *big.Int, _elRewardAddr common.Address, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingSession) LargeStakings(arg0 *big.Int) (struct{ ... }, error)

+ func (_LargeStaking *LargeStakingSession) LargeUnstake(_stakingId *big.Int, _amount *big.Int) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingSession) MAXSLASHAMOUNT() (*big.Int, error)

+ func (_LargeStaking *LargeStakingSession) MINSTAKEAMOUNT() (*big.Int, error)

+ func (_LargeStaking *LargeStakingSession) MigrateStake(_owner common.Address, _elRewardAddr common.Address, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingSession) NodeOperatorRegistryContract() (common.Address, error)

+ func (_LargeStaking *LargeStakingSession) OperatorPrivateRewards(arg0 *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingSession) OperatorSharedRewards(arg0 *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingSession) OperatorSlashContract() (common.Address, error)

+ func (_LargeStaking *LargeStakingSession) Owner() (common.Address, error)

+ func (_LargeStaking *LargeStakingSession) ProxiableUUID() ([32]byte, error)

+ func (_LargeStaking *LargeStakingSession) RegisterValidator(_stakingId *big.Int, _pubkeys [][]byte, _signatures [][]byte, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingSession) RenounceOwnership() (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingSession) ReportCLStakingData(_clStakingExitInfo []CLStakingExitInfo, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingSession) Reward(_stakingId *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingSession) SetLargeStakingSetting(_dao common.Address, _daoVaultAddress common.Address, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingSession) SettleElPrivateReward(_stakingId *big.Int) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingSession) SettleElSharedReward(_operatorId *big.Int) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingSession) StartupSharedRewardPool(_operatorId *big.Int) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingSession) TotalLargeStakingCounts() (*big.Int, error)

+ func (_LargeStaking *LargeStakingSession) TotalShares(arg0 *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingSession) UnclaimedPrivateRewards(arg0 *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingSession) UnclaimedSharedRewards(arg0 *big.Int) (*big.Int, error)

+ func (_LargeStaking *LargeStakingSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingSession) ValidatorInfo(arg0 []byte) (struct{ ... }, error)

+ func (_LargeStaking *LargeStakingSession) ValuePerShare(arg0 *big.Int) (*big.Int, error)

+ type LargeStakingSharedRewardPoolStart struct

+ ElRewardPoolAddr common.Address

+ OperatorId *big.Int

+ Raw types.Log

+ type LargeStakingSharedRewardPoolStartIterator struct

+ Event *LargeStakingSharedRewardPoolStart

+ func (it *LargeStakingSharedRewardPoolStartIterator) Close() error

+ func (it *LargeStakingSharedRewardPoolStartIterator) Error() error

+ func (it *LargeStakingSharedRewardPoolStartIterator) Next() bool

+ type LargeStakingStakingInfo struct

+ AlreadyUsedAmount *big.Int

+ ElRewardAddr common.Address

+ IsELRewardSharing bool

+ OperatorId *big.Int

+ Owner common.Address

+ StakingAmount *big.Int

+ StakingId *big.Int

+ UnstakeAmount *big.Int

+ UnstakeRequestAmount *big.Int

+ WithdrawCredentials [32]byte

+ type LargeStakingTransactor struct

+ func NewLargeStakingTransactor(address common.Address, transactor bind.ContractTransactor) (*LargeStakingTransactor, error)

+ func (_LargeStaking *LargeStakingTransactor) AppendLargeStake(opts *bind.TransactOpts, _stakingId *big.Int, _owner common.Address, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactor) AppendMigrateStake(opts *bind.TransactOpts, _stakingId *big.Int, _owner common.Address, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactor) ClaimRewardsOfDao(opts *bind.TransactOpts, _stakingIds []*big.Int) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactor) ClaimRewardsOfOperator(opts *bind.TransactOpts, _operatorId *big.Int, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactor) ClaimRewardsOfUser(opts *bind.TransactOpts, _stakingId *big.Int, rewards *big.Int) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactor) Initialize(opts *bind.TransactOpts, _dao common.Address, _daoVaultAddress common.Address, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactor) LargeStake(opts *bind.TransactOpts, _operatorId *big.Int, _elRewardAddr common.Address, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactor) LargeUnstake(opts *bind.TransactOpts, _stakingId *big.Int, _amount *big.Int) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactor) MigrateStake(opts *bind.TransactOpts, _owner common.Address, _elRewardAddr common.Address, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactor) RegisterValidator(opts *bind.TransactOpts, _stakingId *big.Int, _pubkeys [][]byte, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactor) ReportCLStakingData(opts *bind.TransactOpts, _clStakingExitInfo []CLStakingExitInfo, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactor) SetLargeStakingSetting(opts *bind.TransactOpts, _dao common.Address, _daoVaultAddress common.Address, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactor) SettleElPrivateReward(opts *bind.TransactOpts, _stakingId *big.Int) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactor) SettleElSharedReward(opts *bind.TransactOpts, _operatorId *big.Int) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactor) StartupSharedRewardPool(opts *bind.TransactOpts, _operatorId *big.Int) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactor) UpgradeTo(opts *bind.TransactOpts, newImplementation common.Address) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactor) UpgradeToAndCall(opts *bind.TransactOpts, newImplementation common.Address, data []byte) (*types.Transaction, error)

+ type LargeStakingTransactorRaw struct

+ Contract *LargeStakingTransactor

+ func (_LargeStaking *LargeStakingTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type LargeStakingTransactorSession struct

+ Contract *LargeStakingTransactor

+ TransactOpts bind.TransactOpts

+ func (_LargeStaking *LargeStakingTransactorSession) AppendLargeStake(_stakingId *big.Int, _owner common.Address, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactorSession) AppendMigrateStake(_stakingId *big.Int, _owner common.Address, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactorSession) ClaimRewardsOfDao(_stakingIds []*big.Int) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactorSession) ClaimRewardsOfOperator(_operatorId *big.Int, _privatePoolStakingIds []*big.Int) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactorSession) ClaimRewardsOfUser(_stakingId *big.Int, rewards *big.Int) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactorSession) Initialize(_dao common.Address, _daoVaultAddress common.Address, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactorSession) LargeStake(_operatorId *big.Int, _elRewardAddr common.Address, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactorSession) LargeUnstake(_stakingId *big.Int, _amount *big.Int) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactorSession) MigrateStake(_owner common.Address, _elRewardAddr common.Address, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactorSession) RegisterValidator(_stakingId *big.Int, _pubkeys [][]byte, _signatures [][]byte, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactorSession) ReportCLStakingData(_clStakingExitInfo []CLStakingExitInfo, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactorSession) SetLargeStakingSetting(_dao common.Address, _daoVaultAddress common.Address, ...) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactorSession) SettleElPrivateReward(_stakingId *big.Int) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactorSession) SettleElSharedReward(_operatorId *big.Int) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactorSession) StartupSharedRewardPool(_operatorId *big.Int) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactorSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error)

+ func (_LargeStaking *LargeStakingTransactorSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error)

+ type LargeStakingUpgraded struct

+ Implementation common.Address

+ Raw types.Log

+ type LargeStakingUpgradedIterator struct

+ Event *LargeStakingUpgraded

+ func (it *LargeStakingUpgradedIterator) Close() error

+ func (it *LargeStakingUpgradedIterator) Error() error

+ func (it *LargeStakingUpgradedIterator) Next() bool

+ type LargeStakingUserRewardClaimed struct

+ Beneficiary common.Address

+ Raw types.Log

+ Rewards *big.Int

+ StakingId *big.Int

+ type LargeStakingUserRewardClaimedIterator struct

+ Event *LargeStakingUserRewardClaimed

+ func (it *LargeStakingUserRewardClaimedIterator) Close() error

+ func (it *LargeStakingUserRewardClaimedIterator) Error() error

+ func (it *LargeStakingUserRewardClaimedIterator) Next() bool

+ type LargeStakingValidatorExitReport struct

+ OperatorId *big.Int

+ Pubkey []byte

+ Raw types.Log

+ type LargeStakingValidatorExitReportIterator struct

+ Event *LargeStakingValidatorExitReport

+ func (it *LargeStakingValidatorExitReportIterator) Close() error

+ func (it *LargeStakingValidatorExitReportIterator) Error() error

+ func (it *LargeStakingValidatorExitReportIterator) Next() bool

+ type LargeStakingValidatorRegistered struct

+ OperatorId *big.Int

+ PubKey []byte

+ Raw types.Log

+ StakeingId *big.Int

+ type LargeStakingValidatorRegisteredIterator struct

+ Event *LargeStakingValidatorRegistered

+ func (it *LargeStakingValidatorRegisteredIterator) Close() error

+ func (it *LargeStakingValidatorRegisteredIterator) Error() error

+ func (it *LargeStakingValidatorRegisteredIterator) Next() bool

v0.1.0-rc3

Jul 10, 2023

v0.1.0-rc2

Jul 7, 2023

v0.1.0-rc1

Jul 7, 2023

v0.1.0-beta2

Jul 6, 2023

v0.1.0-beta1

Jul 5, 2023

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL