Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

ssv_network

package

Go to main page

Versions in this module

v0

v0.4.3

Jul 29, 2024

v0.4.2

Oct 13, 2023

v0.4.1

Sep 8, 2023

v0.4.0

Sep 7, 2023

v0.3.1

Aug 24, 2023

v0.3.0

Aug 24, 2023

v0.2.3

Aug 18, 2023

v0.2.2

Aug 16, 2023

v0.2.1

Aug 15, 2023

v0.2.0

Aug 15, 2023

v0.1.0

Aug 2, 2023

Changes in this version

+ var SsvNetworkABI = SsvNetworkMetaData.ABI

+ var SsvNetworkMetaData = &bind.MetaData

+ type ISSVNetworkCoreCluster struct

+ Active bool

+ Balance *big.Int

+ Index uint64

+ NetworkFeeIndex uint64

+ ValidatorCount uint32

+ type SsvNetwork struct

+ func NewSsvNetwork(address common.Address, backend bind.ContractBackend) (*SsvNetwork, error)

+ type SsvNetworkAdminChanged struct

+ NewAdmin common.Address

+ PreviousAdmin common.Address

+ Raw types.Log

+ type SsvNetworkAdminChangedIterator struct

+ Event *SsvNetworkAdminChanged

+ func (it *SsvNetworkAdminChangedIterator) Close() error

+ func (it *SsvNetworkAdminChangedIterator) Error() error

+ func (it *SsvNetworkAdminChangedIterator) Next() bool

+ type SsvNetworkBeaconUpgraded struct

+ Beacon common.Address

+ Raw types.Log

+ type SsvNetworkBeaconUpgradedIterator struct

+ Event *SsvNetworkBeaconUpgraded

+ func (it *SsvNetworkBeaconUpgradedIterator) Close() error

+ func (it *SsvNetworkBeaconUpgradedIterator) Error() error

+ func (it *SsvNetworkBeaconUpgradedIterator) Next() bool

+ type SsvNetworkCaller struct

+ func NewSsvNetworkCaller(address common.Address, caller bind.ContractCaller) (*SsvNetworkCaller, error)

+ func (_SsvNetwork *SsvNetworkCaller) GetRegisterAuth(opts *bind.CallOpts, userAddress common.Address) (struct{ ... }, error)

+ func (_SsvNetwork *SsvNetworkCaller) GetVersion(opts *bind.CallOpts) (string, error)

+ func (_SsvNetwork *SsvNetworkCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_SsvNetwork *SsvNetworkCaller) PendingOwner(opts *bind.CallOpts) (common.Address, error)

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

+ type SsvNetworkCallerRaw struct

+ Contract *SsvNetworkCaller

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

+ type SsvNetworkCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SsvNetworkCaller

+ func (_SsvNetwork *SsvNetworkCallerSession) GetRegisterAuth(userAddress common.Address) (struct{ ... }, error)

+ func (_SsvNetwork *SsvNetworkCallerSession) GetVersion() (string, error)

+ func (_SsvNetwork *SsvNetworkCallerSession) Owner() (common.Address, error)

+ func (_SsvNetwork *SsvNetworkCallerSession) PendingOwner() (common.Address, error)

+ func (_SsvNetwork *SsvNetworkCallerSession) ProxiableUUID() ([32]byte, error)

+ type SsvNetworkClusterDeposited struct

+ Cluster ISSVNetworkCoreCluster

+ OperatorIds []uint64

+ Owner common.Address

+ Raw types.Log

+ Value *big.Int

+ type SsvNetworkClusterDepositedIterator struct

+ Event *SsvNetworkClusterDeposited

+ func (it *SsvNetworkClusterDepositedIterator) Close() error

+ func (it *SsvNetworkClusterDepositedIterator) Error() error

+ func (it *SsvNetworkClusterDepositedIterator) Next() bool

+ type SsvNetworkClusterLiquidated struct

+ Cluster ISSVNetworkCoreCluster

+ OperatorIds []uint64

+ Owner common.Address

+ Raw types.Log

+ type SsvNetworkClusterLiquidatedIterator struct

+ Event *SsvNetworkClusterLiquidated

+ func (it *SsvNetworkClusterLiquidatedIterator) Close() error

+ func (it *SsvNetworkClusterLiquidatedIterator) Error() error

+ func (it *SsvNetworkClusterLiquidatedIterator) Next() bool

+ type SsvNetworkClusterReactivated struct

+ Cluster ISSVNetworkCoreCluster

+ OperatorIds []uint64

+ Owner common.Address

+ Raw types.Log

+ type SsvNetworkClusterReactivatedIterator struct

+ Event *SsvNetworkClusterReactivated

+ func (it *SsvNetworkClusterReactivatedIterator) Close() error

+ func (it *SsvNetworkClusterReactivatedIterator) Error() error

+ func (it *SsvNetworkClusterReactivatedIterator) Next() bool

+ type SsvNetworkClusterWithdrawn struct

+ Cluster ISSVNetworkCoreCluster

+ OperatorIds []uint64

+ Owner common.Address

+ Raw types.Log

+ Value *big.Int

+ type SsvNetworkClusterWithdrawnIterator struct

+ Event *SsvNetworkClusterWithdrawn

+ func (it *SsvNetworkClusterWithdrawnIterator) Close() error

+ func (it *SsvNetworkClusterWithdrawnIterator) Error() error

+ func (it *SsvNetworkClusterWithdrawnIterator) Next() bool

+ type SsvNetworkDeclareOperatorFeePeriodUpdated struct

+ Raw types.Log

+ Value uint64

+ type SsvNetworkDeclareOperatorFeePeriodUpdatedIterator struct

+ Event *SsvNetworkDeclareOperatorFeePeriodUpdated

+ func (it *SsvNetworkDeclareOperatorFeePeriodUpdatedIterator) Close() error

+ func (it *SsvNetworkDeclareOperatorFeePeriodUpdatedIterator) Error() error

+ func (it *SsvNetworkDeclareOperatorFeePeriodUpdatedIterator) Next() bool

+ type SsvNetworkExecuteOperatorFeePeriodUpdated struct

+ Raw types.Log

+ Value uint64

+ type SsvNetworkExecuteOperatorFeePeriodUpdatedIterator struct

+ Event *SsvNetworkExecuteOperatorFeePeriodUpdated

+ func (it *SsvNetworkExecuteOperatorFeePeriodUpdatedIterator) Close() error

+ func (it *SsvNetworkExecuteOperatorFeePeriodUpdatedIterator) Error() error

+ func (it *SsvNetworkExecuteOperatorFeePeriodUpdatedIterator) Next() bool

+ type SsvNetworkFeeRecipientAddressUpdated struct

+ Owner common.Address

+ Raw types.Log

+ RecipientAddress common.Address

+ type SsvNetworkFeeRecipientAddressUpdatedIterator struct

+ Event *SsvNetworkFeeRecipientAddressUpdated

+ func (it *SsvNetworkFeeRecipientAddressUpdatedIterator) Close() error

+ func (it *SsvNetworkFeeRecipientAddressUpdatedIterator) Error() error

+ func (it *SsvNetworkFeeRecipientAddressUpdatedIterator) Next() bool

+ type SsvNetworkFilterer struct

+ func NewSsvNetworkFilterer(address common.Address, filterer bind.ContractFilterer) (*SsvNetworkFilterer, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*SsvNetworkAdminChangedIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*SsvNetworkBeaconUpgradedIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterClusterDeposited(opts *bind.FilterOpts, owner []common.Address) (*SsvNetworkClusterDepositedIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterClusterLiquidated(opts *bind.FilterOpts, owner []common.Address) (*SsvNetworkClusterLiquidatedIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterClusterReactivated(opts *bind.FilterOpts, owner []common.Address) (*SsvNetworkClusterReactivatedIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterClusterWithdrawn(opts *bind.FilterOpts, owner []common.Address) (*SsvNetworkClusterWithdrawnIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterDeclareOperatorFeePeriodUpdated(opts *bind.FilterOpts) (*SsvNetworkDeclareOperatorFeePeriodUpdatedIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterExecuteOperatorFeePeriodUpdated(opts *bind.FilterOpts) (*SsvNetworkExecuteOperatorFeePeriodUpdatedIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterFeeRecipientAddressUpdated(opts *bind.FilterOpts, owner []common.Address) (*SsvNetworkFeeRecipientAddressUpdatedIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterInitialized(opts *bind.FilterOpts) (*SsvNetworkInitializedIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterLiquidationThresholdPeriodUpdated(opts *bind.FilterOpts) (*SsvNetworkLiquidationThresholdPeriodUpdatedIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterMinimumLiquidationCollateralUpdated(opts *bind.FilterOpts) (*SsvNetworkMinimumLiquidationCollateralUpdatedIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterNetworkEarningsWithdrawn(opts *bind.FilterOpts) (*SsvNetworkNetworkEarningsWithdrawnIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterNetworkFeeUpdated(opts *bind.FilterOpts) (*SsvNetworkNetworkFeeUpdatedIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterOperatorAdded(opts *bind.FilterOpts, operatorId []uint64, owner []common.Address) (*SsvNetworkOperatorAddedIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterOperatorFeeDeclarationCancelled(opts *bind.FilterOpts, owner []common.Address, operatorId []uint64) (*SsvNetworkOperatorFeeDeclarationCancelledIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterOperatorFeeDeclared(opts *bind.FilterOpts, owner []common.Address, operatorId []uint64) (*SsvNetworkOperatorFeeDeclaredIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterOperatorFeeExecuted(opts *bind.FilterOpts, owner []common.Address, operatorId []uint64) (*SsvNetworkOperatorFeeExecutedIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterOperatorFeeIncreaseLimitUpdated(opts *bind.FilterOpts) (*SsvNetworkOperatorFeeIncreaseLimitUpdatedIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterOperatorRemoved(opts *bind.FilterOpts, operatorId []uint64) (*SsvNetworkOperatorRemovedIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterOperatorWhitelistUpdated(opts *bind.FilterOpts, operatorId []uint64) (*SsvNetworkOperatorWhitelistUpdatedIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterOperatorWithdrawn(opts *bind.FilterOpts, owner []common.Address, operatorId []uint64) (*SsvNetworkOperatorWithdrawnIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterOwnershipTransferStarted(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*SsvNetworkOwnershipTransferStartedIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*SsvNetworkOwnershipTransferredIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*SsvNetworkUpgradedIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterValidatorAdded(opts *bind.FilterOpts, owner []common.Address) (*SsvNetworkValidatorAddedIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) FilterValidatorRemoved(opts *bind.FilterOpts, owner []common.Address) (*SsvNetworkValidatorRemovedIterator, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseAdminChanged(log types.Log) (*SsvNetworkAdminChanged, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseBeaconUpgraded(log types.Log) (*SsvNetworkBeaconUpgraded, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseClusterDeposited(log types.Log) (*SsvNetworkClusterDeposited, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseClusterLiquidated(log types.Log) (*SsvNetworkClusterLiquidated, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseClusterReactivated(log types.Log) (*SsvNetworkClusterReactivated, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseClusterWithdrawn(log types.Log) (*SsvNetworkClusterWithdrawn, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseDeclareOperatorFeePeriodUpdated(log types.Log) (*SsvNetworkDeclareOperatorFeePeriodUpdated, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseExecuteOperatorFeePeriodUpdated(log types.Log) (*SsvNetworkExecuteOperatorFeePeriodUpdated, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseFeeRecipientAddressUpdated(log types.Log) (*SsvNetworkFeeRecipientAddressUpdated, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseInitialized(log types.Log) (*SsvNetworkInitialized, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseLiquidationThresholdPeriodUpdated(log types.Log) (*SsvNetworkLiquidationThresholdPeriodUpdated, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseMinimumLiquidationCollateralUpdated(log types.Log) (*SsvNetworkMinimumLiquidationCollateralUpdated, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseNetworkEarningsWithdrawn(log types.Log) (*SsvNetworkNetworkEarningsWithdrawn, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseNetworkFeeUpdated(log types.Log) (*SsvNetworkNetworkFeeUpdated, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseOperatorAdded(log types.Log) (*SsvNetworkOperatorAdded, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseOperatorFeeDeclarationCancelled(log types.Log) (*SsvNetworkOperatorFeeDeclarationCancelled, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseOperatorFeeDeclared(log types.Log) (*SsvNetworkOperatorFeeDeclared, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseOperatorFeeExecuted(log types.Log) (*SsvNetworkOperatorFeeExecuted, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseOperatorFeeIncreaseLimitUpdated(log types.Log) (*SsvNetworkOperatorFeeIncreaseLimitUpdated, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseOperatorRemoved(log types.Log) (*SsvNetworkOperatorRemoved, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseOperatorWhitelistUpdated(log types.Log) (*SsvNetworkOperatorWhitelistUpdated, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseOperatorWithdrawn(log types.Log) (*SsvNetworkOperatorWithdrawn, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseOwnershipTransferStarted(log types.Log) (*SsvNetworkOwnershipTransferStarted, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseOwnershipTransferred(log types.Log) (*SsvNetworkOwnershipTransferred, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseUpgraded(log types.Log) (*SsvNetworkUpgraded, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseValidatorAdded(log types.Log) (*SsvNetworkValidatorAdded, error)

+ func (_SsvNetwork *SsvNetworkFilterer) ParseValidatorRemoved(log types.Log) (*SsvNetworkValidatorRemoved, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *SsvNetworkAdminChanged) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *SsvNetworkBeaconUpgraded, ...) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchClusterDeposited(opts *bind.WatchOpts, sink chan<- *SsvNetworkClusterDeposited, ...) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchClusterLiquidated(opts *bind.WatchOpts, sink chan<- *SsvNetworkClusterLiquidated, ...) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchClusterReactivated(opts *bind.WatchOpts, sink chan<- *SsvNetworkClusterReactivated, ...) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchClusterWithdrawn(opts *bind.WatchOpts, sink chan<- *SsvNetworkClusterWithdrawn, ...) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchDeclareOperatorFeePeriodUpdated(opts *bind.WatchOpts, sink chan<- *SsvNetworkDeclareOperatorFeePeriodUpdated) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchExecuteOperatorFeePeriodUpdated(opts *bind.WatchOpts, sink chan<- *SsvNetworkExecuteOperatorFeePeriodUpdated) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchFeeRecipientAddressUpdated(opts *bind.WatchOpts, sink chan<- *SsvNetworkFeeRecipientAddressUpdated, ...) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *SsvNetworkInitialized) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchLiquidationThresholdPeriodUpdated(opts *bind.WatchOpts, sink chan<- *SsvNetworkLiquidationThresholdPeriodUpdated) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchMinimumLiquidationCollateralUpdated(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchNetworkEarningsWithdrawn(opts *bind.WatchOpts, sink chan<- *SsvNetworkNetworkEarningsWithdrawn) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchNetworkFeeUpdated(opts *bind.WatchOpts, sink chan<- *SsvNetworkNetworkFeeUpdated) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchOperatorAdded(opts *bind.WatchOpts, sink chan<- *SsvNetworkOperatorAdded, ...) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchOperatorFeeDeclarationCancelled(opts *bind.WatchOpts, sink chan<- *SsvNetworkOperatorFeeDeclarationCancelled, ...) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchOperatorFeeDeclared(opts *bind.WatchOpts, sink chan<- *SsvNetworkOperatorFeeDeclared, ...) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchOperatorFeeExecuted(opts *bind.WatchOpts, sink chan<- *SsvNetworkOperatorFeeExecuted, ...) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchOperatorFeeIncreaseLimitUpdated(opts *bind.WatchOpts, sink chan<- *SsvNetworkOperatorFeeIncreaseLimitUpdated) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchOperatorRemoved(opts *bind.WatchOpts, sink chan<- *SsvNetworkOperatorRemoved, ...) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchOperatorWhitelistUpdated(opts *bind.WatchOpts, sink chan<- *SsvNetworkOperatorWhitelistUpdated, ...) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchOperatorWithdrawn(opts *bind.WatchOpts, sink chan<- *SsvNetworkOperatorWithdrawn, ...) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchOwnershipTransferStarted(opts *bind.WatchOpts, sink chan<- *SsvNetworkOwnershipTransferStarted, ...) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *SsvNetworkOwnershipTransferred, ...) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *SsvNetworkUpgraded, ...) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchValidatorAdded(opts *bind.WatchOpts, sink chan<- *SsvNetworkValidatorAdded, ...) (event.Subscription, error)

+ func (_SsvNetwork *SsvNetworkFilterer) WatchValidatorRemoved(opts *bind.WatchOpts, sink chan<- *SsvNetworkValidatorRemoved, ...) (event.Subscription, error)

+ type SsvNetworkInitialized struct

+ Raw types.Log

+ Version uint8

+ type SsvNetworkInitializedIterator struct

+ Event *SsvNetworkInitialized

+ func (it *SsvNetworkInitializedIterator) Close() error

+ func (it *SsvNetworkInitializedIterator) Error() error

+ func (it *SsvNetworkInitializedIterator) Next() bool

+ type SsvNetworkLiquidationThresholdPeriodUpdated struct

+ Raw types.Log

+ Value uint64

+ type SsvNetworkLiquidationThresholdPeriodUpdatedIterator struct

+ Event *SsvNetworkLiquidationThresholdPeriodUpdated

+ func (it *SsvNetworkLiquidationThresholdPeriodUpdatedIterator) Close() error

+ func (it *SsvNetworkLiquidationThresholdPeriodUpdatedIterator) Error() error

+ func (it *SsvNetworkLiquidationThresholdPeriodUpdatedIterator) Next() bool

+ type SsvNetworkMinimumLiquidationCollateralUpdated struct

+ Raw types.Log

+ Value *big.Int

+ type SsvNetworkMinimumLiquidationCollateralUpdatedIterator struct

+ Event *SsvNetworkMinimumLiquidationCollateralUpdated

+ func (it *SsvNetworkMinimumLiquidationCollateralUpdatedIterator) Close() error

+ func (it *SsvNetworkMinimumLiquidationCollateralUpdatedIterator) Error() error

+ func (it *SsvNetworkMinimumLiquidationCollateralUpdatedIterator) Next() bool

+ type SsvNetworkNetworkEarningsWithdrawn struct

+ Raw types.Log

+ Recipient common.Address

+ Value *big.Int

+ type SsvNetworkNetworkEarningsWithdrawnIterator struct

+ Event *SsvNetworkNetworkEarningsWithdrawn

+ func (it *SsvNetworkNetworkEarningsWithdrawnIterator) Close() error

+ func (it *SsvNetworkNetworkEarningsWithdrawnIterator) Error() error

+ func (it *SsvNetworkNetworkEarningsWithdrawnIterator) Next() bool

+ type SsvNetworkNetworkFeeUpdated struct

+ NewFee *big.Int

+ OldFee *big.Int

+ Raw types.Log

+ type SsvNetworkNetworkFeeUpdatedIterator struct

+ Event *SsvNetworkNetworkFeeUpdated

+ func (it *SsvNetworkNetworkFeeUpdatedIterator) Close() error

+ func (it *SsvNetworkNetworkFeeUpdatedIterator) Error() error

+ func (it *SsvNetworkNetworkFeeUpdatedIterator) Next() bool

+ type SsvNetworkOperatorAdded struct

+ Fee *big.Int

+ OperatorId uint64

+ Owner common.Address

+ PublicKey []byte

+ Raw types.Log

+ type SsvNetworkOperatorAddedIterator struct

+ Event *SsvNetworkOperatorAdded

+ func (it *SsvNetworkOperatorAddedIterator) Close() error

+ func (it *SsvNetworkOperatorAddedIterator) Error() error

+ func (it *SsvNetworkOperatorAddedIterator) Next() bool

+ type SsvNetworkOperatorFeeDeclarationCancelled struct

+ OperatorId uint64

+ Owner common.Address

+ Raw types.Log

+ type SsvNetworkOperatorFeeDeclarationCancelledIterator struct

+ Event *SsvNetworkOperatorFeeDeclarationCancelled

+ func (it *SsvNetworkOperatorFeeDeclarationCancelledIterator) Close() error

+ func (it *SsvNetworkOperatorFeeDeclarationCancelledIterator) Error() error

+ func (it *SsvNetworkOperatorFeeDeclarationCancelledIterator) Next() bool

+ type SsvNetworkOperatorFeeDeclared struct

+ BlockNumber *big.Int

+ Fee *big.Int

+ OperatorId uint64

+ Owner common.Address

+ Raw types.Log

+ type SsvNetworkOperatorFeeDeclaredIterator struct

+ Event *SsvNetworkOperatorFeeDeclared

+ func (it *SsvNetworkOperatorFeeDeclaredIterator) Close() error

+ func (it *SsvNetworkOperatorFeeDeclaredIterator) Error() error

+ func (it *SsvNetworkOperatorFeeDeclaredIterator) Next() bool

+ type SsvNetworkOperatorFeeExecuted struct

+ BlockNumber *big.Int

+ Fee *big.Int

+ OperatorId uint64

+ Owner common.Address

+ Raw types.Log

+ type SsvNetworkOperatorFeeExecutedIterator struct

+ Event *SsvNetworkOperatorFeeExecuted

+ func (it *SsvNetworkOperatorFeeExecutedIterator) Close() error

+ func (it *SsvNetworkOperatorFeeExecutedIterator) Error() error

+ func (it *SsvNetworkOperatorFeeExecutedIterator) Next() bool

+ type SsvNetworkOperatorFeeIncreaseLimitUpdated struct

+ Raw types.Log

+ Value uint64

+ type SsvNetworkOperatorFeeIncreaseLimitUpdatedIterator struct

+ Event *SsvNetworkOperatorFeeIncreaseLimitUpdated

+ func (it *SsvNetworkOperatorFeeIncreaseLimitUpdatedIterator) Close() error

+ func (it *SsvNetworkOperatorFeeIncreaseLimitUpdatedIterator) Error() error

+ func (it *SsvNetworkOperatorFeeIncreaseLimitUpdatedIterator) Next() bool

+ type SsvNetworkOperatorRemoved struct

+ OperatorId uint64

+ Raw types.Log

+ type SsvNetworkOperatorRemovedIterator struct

+ Event *SsvNetworkOperatorRemoved

+ func (it *SsvNetworkOperatorRemovedIterator) Close() error

+ func (it *SsvNetworkOperatorRemovedIterator) Error() error

+ func (it *SsvNetworkOperatorRemovedIterator) Next() bool

+ type SsvNetworkOperatorWhitelistUpdated struct

+ OperatorId uint64

+ Raw types.Log

+ Whitelisted common.Address

+ type SsvNetworkOperatorWhitelistUpdatedIterator struct

+ Event *SsvNetworkOperatorWhitelistUpdated

+ func (it *SsvNetworkOperatorWhitelistUpdatedIterator) Close() error

+ func (it *SsvNetworkOperatorWhitelistUpdatedIterator) Error() error

+ func (it *SsvNetworkOperatorWhitelistUpdatedIterator) Next() bool

+ type SsvNetworkOperatorWithdrawn struct

+ OperatorId uint64

+ Owner common.Address

+ Raw types.Log

+ Value *big.Int

+ type SsvNetworkOperatorWithdrawnIterator struct

+ Event *SsvNetworkOperatorWithdrawn

+ func (it *SsvNetworkOperatorWithdrawnIterator) Close() error

+ func (it *SsvNetworkOperatorWithdrawnIterator) Error() error

+ func (it *SsvNetworkOperatorWithdrawnIterator) Next() bool

+ type SsvNetworkOwnershipTransferStarted struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type SsvNetworkOwnershipTransferStartedIterator struct

+ Event *SsvNetworkOwnershipTransferStarted

+ func (it *SsvNetworkOwnershipTransferStartedIterator) Close() error

+ func (it *SsvNetworkOwnershipTransferStartedIterator) Error() error

+ func (it *SsvNetworkOwnershipTransferStartedIterator) Next() bool

+ type SsvNetworkOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type SsvNetworkOwnershipTransferredIterator struct

+ Event *SsvNetworkOwnershipTransferred

+ func (it *SsvNetworkOwnershipTransferredIterator) Close() error

+ func (it *SsvNetworkOwnershipTransferredIterator) Error() error

+ func (it *SsvNetworkOwnershipTransferredIterator) Next() bool

+ type SsvNetworkRaw struct

+ Contract *SsvNetwork

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

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

+ func (_SsvNetwork *SsvNetworkRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SsvNetworkSession struct

+ CallOpts bind.CallOpts

+ Contract *SsvNetwork

+ TransactOpts bind.TransactOpts

+ func (_SsvNetwork *SsvNetworkSession) AcceptOwnership() (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) CancelDeclaredOperatorFee(operatorId uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) DeclareOperatorFee(operatorId uint64, fee *big.Int) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) Deposit(clusterOwner common.Address, operatorIds []uint64, amount *big.Int, ...) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) ExecuteOperatorFee(operatorId uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) Fallback(calldata []byte) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) GetRegisterAuth(userAddress common.Address) (struct{ ... }, error)

+ func (_SsvNetwork *SsvNetworkSession) GetVersion() (string, error)

+ func (_SsvNetwork *SsvNetworkSession) Initialize(token_ common.Address, ssvOperators_ common.Address, ...) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) Liquidate(clusterOwner common.Address, operatorIds []uint64, ...) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) Owner() (common.Address, error)

+ func (_SsvNetwork *SsvNetworkSession) PendingOwner() (common.Address, error)

+ func (_SsvNetwork *SsvNetworkSession) ProxiableUUID() ([32]byte, error)

+ func (_SsvNetwork *SsvNetworkSession) Reactivate(operatorIds []uint64, amount *big.Int, cluster ISSVNetworkCoreCluster) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) ReduceOperatorFee(operatorId uint64, fee *big.Int) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) RegisterOperator(publicKey []byte, fee *big.Int) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) RegisterValidator(publicKey []byte, operatorIds []uint64, sharesData []byte, amount *big.Int, ...) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) RemoveOperator(operatorId uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) RemoveValidator(publicKey []byte, operatorIds []uint64, cluster ISSVNetworkCoreCluster) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) RenounceOwnership() (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) SetFeeRecipientAddress(recipientAddress common.Address) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) SetOperatorWhitelist(operatorId uint64, whitelisted common.Address) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) SetRegisterAuth(userAddress common.Address, authOperator bool, authValidator bool) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) UpdateDeclareOperatorFeePeriod(timeInSeconds uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) UpdateExecuteOperatorFeePeriod(timeInSeconds uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) UpdateLiquidationThresholdPeriod(blocks uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) UpdateMinimumLiquidationCollateral(amount *big.Int) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) UpdateModule(moduleId uint8, moduleAddress common.Address) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) UpdateNetworkFee(fee *big.Int) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) UpdateOperatorFeeIncreaseLimit(percentage uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error)

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

+ func (_SsvNetwork *SsvNetworkSession) Withdraw(operatorIds []uint64, amount *big.Int, cluster ISSVNetworkCoreCluster) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) WithdrawAllOperatorEarnings(operatorId uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) WithdrawNetworkEarnings(amount *big.Int) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkSession) WithdrawOperatorEarnings(operatorId uint64, amount *big.Int) (*types.Transaction, error)

+ type SsvNetworkTransactor struct

+ func NewSsvNetworkTransactor(address common.Address, transactor bind.ContractTransactor) (*SsvNetworkTransactor, error)

+ func (_SsvNetwork *SsvNetworkTransactor) AcceptOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) CancelDeclaredOperatorFee(opts *bind.TransactOpts, operatorId uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) DeclareOperatorFee(opts *bind.TransactOpts, operatorId uint64, fee *big.Int) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) Deposit(opts *bind.TransactOpts, clusterOwner common.Address, operatorIds []uint64, ...) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) ExecuteOperatorFee(opts *bind.TransactOpts, operatorId uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) Initialize(opts *bind.TransactOpts, token_ common.Address, ssvOperators_ common.Address, ...) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) Liquidate(opts *bind.TransactOpts, clusterOwner common.Address, operatorIds []uint64, ...) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) Reactivate(opts *bind.TransactOpts, operatorIds []uint64, amount *big.Int, ...) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) ReduceOperatorFee(opts *bind.TransactOpts, operatorId uint64, fee *big.Int) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) RegisterOperator(opts *bind.TransactOpts, publicKey []byte, fee *big.Int) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) RegisterValidator(opts *bind.TransactOpts, publicKey []byte, operatorIds []uint64, ...) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) RemoveOperator(opts *bind.TransactOpts, operatorId uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) RemoveValidator(opts *bind.TransactOpts, publicKey []byte, operatorIds []uint64, ...) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) SetFeeRecipientAddress(opts *bind.TransactOpts, recipientAddress common.Address) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) SetOperatorWhitelist(opts *bind.TransactOpts, operatorId uint64, whitelisted common.Address) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) SetRegisterAuth(opts *bind.TransactOpts, userAddress common.Address, authOperator bool, ...) (*types.Transaction, error)

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

+ func (_SsvNetwork *SsvNetworkTransactor) UpdateDeclareOperatorFeePeriod(opts *bind.TransactOpts, timeInSeconds uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) UpdateExecuteOperatorFeePeriod(opts *bind.TransactOpts, timeInSeconds uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) UpdateLiquidationThresholdPeriod(opts *bind.TransactOpts, blocks uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) UpdateMinimumLiquidationCollateral(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) UpdateModule(opts *bind.TransactOpts, moduleId uint8, moduleAddress common.Address) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) UpdateNetworkFee(opts *bind.TransactOpts, fee *big.Int) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) UpdateOperatorFeeIncreaseLimit(opts *bind.TransactOpts, percentage uint64) (*types.Transaction, error)

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

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

+ func (_SsvNetwork *SsvNetworkTransactor) Withdraw(opts *bind.TransactOpts, operatorIds []uint64, amount *big.Int, ...) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) WithdrawAllOperatorEarnings(opts *bind.TransactOpts, operatorId uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) WithdrawNetworkEarnings(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactor) WithdrawOperatorEarnings(opts *bind.TransactOpts, operatorId uint64, amount *big.Int) (*types.Transaction, error)

+ type SsvNetworkTransactorRaw struct

+ Contract *SsvNetworkTransactor

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

+ func (_SsvNetwork *SsvNetworkTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SsvNetworkTransactorSession struct

+ Contract *SsvNetworkTransactor

+ TransactOpts bind.TransactOpts

+ func (_SsvNetwork *SsvNetworkTransactorSession) AcceptOwnership() (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) CancelDeclaredOperatorFee(operatorId uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) DeclareOperatorFee(operatorId uint64, fee *big.Int) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) Deposit(clusterOwner common.Address, operatorIds []uint64, amount *big.Int, ...) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) ExecuteOperatorFee(operatorId uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) Fallback(calldata []byte) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) Initialize(token_ common.Address, ssvOperators_ common.Address, ...) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) Liquidate(clusterOwner common.Address, operatorIds []uint64, ...) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) Reactivate(operatorIds []uint64, amount *big.Int, cluster ISSVNetworkCoreCluster) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) ReduceOperatorFee(operatorId uint64, fee *big.Int) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) RegisterOperator(publicKey []byte, fee *big.Int) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) RegisterValidator(publicKey []byte, operatorIds []uint64, sharesData []byte, amount *big.Int, ...) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) RemoveOperator(operatorId uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) RemoveValidator(publicKey []byte, operatorIds []uint64, cluster ISSVNetworkCoreCluster) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) SetFeeRecipientAddress(recipientAddress common.Address) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) SetOperatorWhitelist(operatorId uint64, whitelisted common.Address) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) SetRegisterAuth(userAddress common.Address, authOperator bool, authValidator bool) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) UpdateDeclareOperatorFeePeriod(timeInSeconds uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) UpdateExecuteOperatorFeePeriod(timeInSeconds uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) UpdateLiquidationThresholdPeriod(blocks uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) UpdateMinimumLiquidationCollateral(amount *big.Int) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) UpdateModule(moduleId uint8, moduleAddress common.Address) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) UpdateNetworkFee(fee *big.Int) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) UpdateOperatorFeeIncreaseLimit(percentage uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error)

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

+ func (_SsvNetwork *SsvNetworkTransactorSession) Withdraw(operatorIds []uint64, amount *big.Int, cluster ISSVNetworkCoreCluster) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) WithdrawAllOperatorEarnings(operatorId uint64) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) WithdrawNetworkEarnings(amount *big.Int) (*types.Transaction, error)

+ func (_SsvNetwork *SsvNetworkTransactorSession) WithdrawOperatorEarnings(operatorId uint64, amount *big.Int) (*types.Transaction, error)

+ type SsvNetworkUpgraded struct

+ Implementation common.Address

+ Raw types.Log

+ type SsvNetworkUpgradedIterator struct

+ Event *SsvNetworkUpgraded

+ func (it *SsvNetworkUpgradedIterator) Close() error

+ func (it *SsvNetworkUpgradedIterator) Error() error

+ func (it *SsvNetworkUpgradedIterator) Next() bool

+ type SsvNetworkValidatorAdded struct

+ Cluster ISSVNetworkCoreCluster

+ OperatorIds []uint64

+ Owner common.Address

+ PublicKey []byte

+ Raw types.Log

+ Shares []byte

+ type SsvNetworkValidatorAddedIterator struct

+ Event *SsvNetworkValidatorAdded

+ func (it *SsvNetworkValidatorAddedIterator) Close() error

+ func (it *SsvNetworkValidatorAddedIterator) Error() error

+ func (it *SsvNetworkValidatorAddedIterator) Next() bool

+ type SsvNetworkValidatorRemoved struct

+ Cluster ISSVNetworkCoreCluster

+ OperatorIds []uint64

+ Owner common.Address

+ PublicKey []byte

+ Raw types.Log

+ type SsvNetworkValidatorRemovedIterator struct

+ Event *SsvNetworkValidatorRemoved

+ func (it *SsvNetworkValidatorRemovedIterator) Close() error

+ func (it *SsvNetworkValidatorRemovedIterator) Error() error

+ func (it *SsvNetworkValidatorRemovedIterator) Next() bool