mainchain

package

Go to main page

Versions in this module

v0

v0.3.0-dev

Nov 7, 2020

v0.2.8

Mar 21, 2022

v0.2.7

Mar 5, 2021

v0.2.6

Nov 18, 2020

Changes in this version

+ var ErrPeersNotMatch = errors.New("channel peers not match")

+ func GetSimplexSeqNum(ledger *CelerLedger, cid CidType, simplexSender, simplexReceiver Addr) (seqNum uint64, err error)

v0.2.5

Nov 5, 2020

Changes in this version

+ const ProposalStatusClosed

+ const ProposalStatusUninitiated

+ const ProposalStatusVoting

+ const Unvoted

+ const VoteAbstain

+ const VoteNo

+ const VoteYes

+ func GetAddressFromKeystore(ksBytes []byte) (string, error)

type DPoSCaller

+ func (_DPoS *DPoSCaller) EnableSlash(opts *bind.CallOpts) (bool, error)

type DPoSCallerSession

+ func (_DPoS *DPoSCallerSession) EnableSlash() (bool, error)

type DPoSSession

+ func (_DPoS *DPoSSession) EnableSlash() (bool, error)

+ func (_DPoS *DPoSSession) UpdateEnableSlash(_enable bool) (*types.Transaction, error)

type DPoSTransactor

+ func (_DPoS *DPoSTransactor) UpdateEnableSlash(opts *bind.TransactOpts, _enable bool) (*types.Transaction, error)

type DPoSTransactorSession

+ func (_DPoS *DPoSTransactorSession) UpdateEnableSlash(_enable bool) (*types.Transaction, error)

type EthClient

+ func (ethClient *EthClient) GetParamProposal(id int64) (*ParamProposal, error)

+ func (ethClient *EthClient) GetParamProposalVote(id int64, voter Addr) (uint8, error)

+ func (ethClient *EthClient) GetParamProposalVotes(id int64) (yesVoters []Addr, noVoters []Addr, ...)

+ func (ethClient *EthClient) GetUIntValue(paramId uint64) (*big.Int, error)

+ type ParamProposal struct

+ Deposit *big.Int

+ NewValue *big.Int

+ Proposer Addr

+ Record *big.Int

+ Status uint8

+ VoteDeadline *big.Int

v0.2.5-dev

Sep 14, 2020

v0.2.4

Sep 14, 2020

v0.2.4-dev

Sep 8, 2020

v0.2.3

Sep 9, 2020

Changes in this version

+ const AdvanceNoticePeriod

+ const MigrationTime

+ const SlashTimeout

type DPoSCaller

+ func (_DPoS *DPoSCaller) IsMigrating(opts *bind.CallOpts) (bool, error)

type DPoSCallerSession

+ func (_DPoS *DPoSCallerSession) IsMigrating() (bool, error)

+ type DPoSCompensate struct

+ Amount *big.Int

+ Indemnitee common.Address

+ Raw types.Log

+ type DPoSCompensateIterator struct

+ Event *DPoSCompensate

+ func (it *DPoSCompensateIterator) Close() error

+ func (it *DPoSCompensateIterator) Error() error

+ func (it *DPoSCompensateIterator) Next() bool

type DPoSFilterer

+ func (_DPoS *DPoSFilterer) FilterCompensate(opts *bind.FilterOpts, indemnitee []common.Address) (*DPoSCompensateIterator, error)

+ func (_DPoS *DPoSFilterer) FilterSlash(opts *bind.FilterOpts, validator []common.Address, delegator []common.Address) (*DPoSSlashIterator, error)

+ func (_DPoS *DPoSFilterer) FilterUpdateDelegatedStake(opts *bind.FilterOpts, delegator []common.Address, candidate []common.Address) (*DPoSUpdateDelegatedStakeIterator, error)

+ func (_DPoS *DPoSFilterer) FilterUpdateMinSelfStake(opts *bind.FilterOpts, candidate []common.Address) (*DPoSUpdateMinSelfStakeIterator, error)

+ func (_DPoS *DPoSFilterer) ParseCompensate(log types.Log) (*DPoSCompensate, error)

+ func (_DPoS *DPoSFilterer) ParseSlash(log types.Log) (*DPoSSlash, error)

+ func (_DPoS *DPoSFilterer) ParseUpdateDelegatedStake(log types.Log) (*DPoSUpdateDelegatedStake, error)

+ func (_DPoS *DPoSFilterer) ParseUpdateMinSelfStake(log types.Log) (*DPoSUpdateMinSelfStake, error)

+ func (_DPoS *DPoSFilterer) WatchCompensate(opts *bind.WatchOpts, sink chan<- *DPoSCompensate, indemnitee []common.Address) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchSlash(opts *bind.WatchOpts, sink chan<- *DPoSSlash, validator []common.Address, ...) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchUpdateDelegatedStake(opts *bind.WatchOpts, sink chan<- *DPoSUpdateDelegatedStake, ...) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchUpdateMinSelfStake(opts *bind.WatchOpts, sink chan<- *DPoSUpdateMinSelfStake, ...) (event.Subscription, error)

type DPoSSession

+ func (_DPoS *DPoSSession) IsMigrating() (bool, error)

+ func (_DPoS *DPoSSession) Slash(_penaltyRequest []byte) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) UpdateMinSelfStake(_minSelfStake *big.Int) (*types.Transaction, error)

+ type DPoSSlash struct

+ Amount *big.Int

+ Delegator common.Address

+ Raw types.Log

+ Validator common.Address

+ type DPoSSlashIterator struct

+ Event *DPoSSlash

+ func (it *DPoSSlashIterator) Close() error

+ func (it *DPoSSlashIterator) Error() error

+ func (it *DPoSSlashIterator) Next() bool

type DPoSTransactor

+ func (_DPoS *DPoSTransactor) Slash(opts *bind.TransactOpts, _penaltyRequest []byte) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) UpdateMinSelfStake(opts *bind.TransactOpts, _minSelfStake *big.Int) (*types.Transaction, error)

type DPoSTransactorSession

+ func (_DPoS *DPoSTransactorSession) Slash(_penaltyRequest []byte) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) UpdateMinSelfStake(_minSelfStake *big.Int) (*types.Transaction, error)

+ type DPoSUpdateDelegatedStake struct

+ Candidate common.Address

+ CandidatePool *big.Int

+ Delegator common.Address

+ DelegatorStake *big.Int

+ Raw types.Log

+ type DPoSUpdateDelegatedStakeIterator struct

+ Event *DPoSUpdateDelegatedStake

+ func (it *DPoSUpdateDelegatedStakeIterator) Close() error

+ func (it *DPoSUpdateDelegatedStakeIterator) Error() error

+ func (it *DPoSUpdateDelegatedStakeIterator) Next() bool

+ type DPoSUpdateMinSelfStake struct

+ Candidate common.Address

+ MinSelfStake *big.Int

+ Raw types.Log

+ type DPoSUpdateMinSelfStakeIterator struct

+ Event *DPoSUpdateMinSelfStake

+ func (it *DPoSUpdateMinSelfStakeIterator) Close() error

+ func (it *DPoSUpdateMinSelfStakeIterator) Error() error

+ func (it *DPoSUpdateMinSelfStakeIterator) Next() bool

type EthClient

+ func (ethClient *EthClient) CheckVotingPower(addrs []Addr) (*big.Int, *big.Int, *big.Int, error)

+ func (ethClient *EthClient) GetValidators() (map[Addr]*ValidatorInfo, *big.Int, *big.Int, error)

+ type ValidatorInfo struct

+ CommissionRate *big.Int

+ MinSelfStake *big.Int

+ RateLockEndTime *big.Int

+ StakingPool *big.Int

v0.2.3-dev

Aug 11, 2020

v0.2.2

Aug 11, 2020

Changes in this version

type DPoSCaller

+ func (_DPoS *DPoSCaller) EnableWhitelist(opts *bind.CallOpts) (bool, error)

+ func (_DPoS *DPoSCaller) IsPauser(opts *bind.CallOpts, account common.Address) (bool, error)

+ func (_DPoS *DPoSCaller) IsWhitelistAdmin(opts *bind.CallOpts, account common.Address) (bool, error)

+ func (_DPoS *DPoSCaller) IsWhitelisted(opts *bind.CallOpts, account common.Address) (bool, error)

+ func (_DPoS *DPoSCaller) Paused(opts *bind.CallOpts) (bool, error)

type DPoSCallerSession

+ func (_DPoS *DPoSCallerSession) EnableWhitelist() (bool, error)

+ func (_DPoS *DPoSCallerSession) IsPauser(account common.Address) (bool, error)

+ func (_DPoS *DPoSCallerSession) IsWhitelistAdmin(account common.Address) (bool, error)

+ func (_DPoS *DPoSCallerSession) IsWhitelisted(account common.Address) (bool, error)

+ func (_DPoS *DPoSCallerSession) Paused() (bool, error)

type DPoSFilterer

+ func (_DPoS *DPoSFilterer) FilterPaused(opts *bind.FilterOpts) (*DPoSPausedIterator, error)

+ func (_DPoS *DPoSFilterer) FilterPauserAdded(opts *bind.FilterOpts, account []common.Address) (*DPoSPauserAddedIterator, error)

+ func (_DPoS *DPoSFilterer) FilterPauserRemoved(opts *bind.FilterOpts, account []common.Address) (*DPoSPauserRemovedIterator, error)

+ func (_DPoS *DPoSFilterer) FilterUnpaused(opts *bind.FilterOpts) (*DPoSUnpausedIterator, error)

+ func (_DPoS *DPoSFilterer) FilterWhitelistAdminAdded(opts *bind.FilterOpts, account []common.Address) (*DPoSWhitelistAdminAddedIterator, error)

+ func (_DPoS *DPoSFilterer) FilterWhitelistAdminRemoved(opts *bind.FilterOpts, account []common.Address) (*DPoSWhitelistAdminRemovedIterator, error)

+ func (_DPoS *DPoSFilterer) FilterWhitelistedAdded(opts *bind.FilterOpts, account []common.Address) (*DPoSWhitelistedAddedIterator, error)

+ func (_DPoS *DPoSFilterer) FilterWhitelistedRemoved(opts *bind.FilterOpts, account []common.Address) (*DPoSWhitelistedRemovedIterator, error)

+ func (_DPoS *DPoSFilterer) ParsePaused(log types.Log) (*DPoSPaused, error)

+ func (_DPoS *DPoSFilterer) ParsePauserAdded(log types.Log) (*DPoSPauserAdded, error)

+ func (_DPoS *DPoSFilterer) ParsePauserRemoved(log types.Log) (*DPoSPauserRemoved, error)

+ func (_DPoS *DPoSFilterer) ParseUnpaused(log types.Log) (*DPoSUnpaused, error)

+ func (_DPoS *DPoSFilterer) ParseWhitelistAdminAdded(log types.Log) (*DPoSWhitelistAdminAdded, error)

+ func (_DPoS *DPoSFilterer) ParseWhitelistAdminRemoved(log types.Log) (*DPoSWhitelistAdminRemoved, error)

+ func (_DPoS *DPoSFilterer) ParseWhitelistedAdded(log types.Log) (*DPoSWhitelistedAdded, error)

+ func (_DPoS *DPoSFilterer) ParseWhitelistedRemoved(log types.Log) (*DPoSWhitelistedRemoved, error)

+ func (_DPoS *DPoSFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *DPoSPaused) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchPauserAdded(opts *bind.WatchOpts, sink chan<- *DPoSPauserAdded, account []common.Address) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchPauserRemoved(opts *bind.WatchOpts, sink chan<- *DPoSPauserRemoved, account []common.Address) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *DPoSUnpaused) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchWhitelistAdminAdded(opts *bind.WatchOpts, sink chan<- *DPoSWhitelistAdminAdded, ...) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchWhitelistAdminRemoved(opts *bind.WatchOpts, sink chan<- *DPoSWhitelistAdminRemoved, ...) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchWhitelistedAdded(opts *bind.WatchOpts, sink chan<- *DPoSWhitelistedAdded, ...) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchWhitelistedRemoved(opts *bind.WatchOpts, sink chan<- *DPoSWhitelistedRemoved, ...) (event.Subscription, error)

+ type DPoSPaused struct

+ Account common.Address

+ Raw types.Log

+ type DPoSPausedIterator struct

+ Event *DPoSPaused

+ func (it *DPoSPausedIterator) Close() error

+ func (it *DPoSPausedIterator) Error() error

+ func (it *DPoSPausedIterator) Next() bool

+ type DPoSPauserAdded struct

+ Account common.Address

+ Raw types.Log

+ type DPoSPauserAddedIterator struct

+ Event *DPoSPauserAdded

+ func (it *DPoSPauserAddedIterator) Close() error

+ func (it *DPoSPauserAddedIterator) Error() error

+ func (it *DPoSPauserAddedIterator) Next() bool

+ type DPoSPauserRemoved struct

+ Account common.Address

+ Raw types.Log

+ type DPoSPauserRemovedIterator struct

+ Event *DPoSPauserRemoved

+ func (it *DPoSPauserRemovedIterator) Close() error

+ func (it *DPoSPauserRemovedIterator) Error() error

+ func (it *DPoSPauserRemovedIterator) Next() bool

type DPoSSession

+ func (_DPoS *DPoSSession) AddPauser(account common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) AddWhitelistAdmin(account common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) AddWhitelisted(account common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) DrainToken(_amount *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) EnableWhitelist() (bool, error)

+ func (_DPoS *DPoSSession) IsPauser(account common.Address) (bool, error)

+ func (_DPoS *DPoSSession) IsWhitelistAdmin(account common.Address) (bool, error)

+ func (_DPoS *DPoSSession) IsWhitelisted(account common.Address) (bool, error)

+ func (_DPoS *DPoSSession) Pause() (*types.Transaction, error)

+ func (_DPoS *DPoSSession) Paused() (bool, error)

+ func (_DPoS *DPoSSession) RemoveWhitelisted(account common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) RenouncePauser() (*types.Transaction, error)

+ func (_DPoS *DPoSSession) RenounceWhitelistAdmin() (*types.Transaction, error)

+ func (_DPoS *DPoSSession) RenounceWhitelisted() (*types.Transaction, error)

+ func (_DPoS *DPoSSession) Unpause() (*types.Transaction, error)

+ func (_DPoS *DPoSSession) UpdateEnableWhitelist(_enable bool) (*types.Transaction, error)

type DPoSTransactor

+ func (_DPoS *DPoSTransactor) AddPauser(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) AddWhitelistAdmin(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) AddWhitelisted(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) DrainToken(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) RemoveWhitelisted(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) RenouncePauser(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) RenounceWhitelistAdmin(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) RenounceWhitelisted(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) UpdateEnableWhitelist(opts *bind.TransactOpts, _enable bool) (*types.Transaction, error)

type DPoSTransactorSession

+ func (_DPoS *DPoSTransactorSession) AddPauser(account common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) AddWhitelistAdmin(account common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) AddWhitelisted(account common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) DrainToken(_amount *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) Pause() (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) RemoveWhitelisted(account common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) RenouncePauser() (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) RenounceWhitelistAdmin() (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) RenounceWhitelisted() (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) Unpause() (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) UpdateEnableWhitelist(_enable bool) (*types.Transaction, error)

+ type DPoSUnpaused struct

+ Account common.Address

+ Raw types.Log

+ type DPoSUnpausedIterator struct

+ Event *DPoSUnpaused

+ func (it *DPoSUnpausedIterator) Close() error

+ func (it *DPoSUnpausedIterator) Error() error

+ func (it *DPoSUnpausedIterator) Next() bool

+ type DPoSWhitelistAdminAdded struct

+ Account common.Address

+ Raw types.Log

+ type DPoSWhitelistAdminAddedIterator struct

+ Event *DPoSWhitelistAdminAdded

+ func (it *DPoSWhitelistAdminAddedIterator) Close() error

+ func (it *DPoSWhitelistAdminAddedIterator) Error() error

+ func (it *DPoSWhitelistAdminAddedIterator) Next() bool

+ type DPoSWhitelistAdminRemoved struct

+ Account common.Address

+ Raw types.Log

+ type DPoSWhitelistAdminRemovedIterator struct

+ Event *DPoSWhitelistAdminRemoved

+ func (it *DPoSWhitelistAdminRemovedIterator) Close() error

+ func (it *DPoSWhitelistAdminRemovedIterator) Error() error

+ func (it *DPoSWhitelistAdminRemovedIterator) Next() bool

+ type DPoSWhitelistedAdded struct

+ Account common.Address

+ Raw types.Log

+ type DPoSWhitelistedAddedIterator struct

+ Event *DPoSWhitelistedAdded

+ func (it *DPoSWhitelistedAddedIterator) Close() error

+ func (it *DPoSWhitelistedAddedIterator) Error() error

+ func (it *DPoSWhitelistedAddedIterator) Next() bool

+ type DPoSWhitelistedRemoved struct

+ Account common.Address

+ Raw types.Log

+ type DPoSWhitelistedRemovedIterator struct

+ Event *DPoSWhitelistedRemoved

+ func (it *DPoSWhitelistedRemovedIterator) Close() error

+ func (it *DPoSWhitelistedRemovedIterator) Error() error

+ func (it *DPoSWhitelistedRemovedIterator) Next() bool

type SGNCaller

+ func (_SGN *SGNCaller) IsOwner(opts *bind.CallOpts) (bool, error)

+ func (_SGN *SGNCaller) IsPauser(opts *bind.CallOpts, account common.Address) (bool, error)

+ func (_SGN *SGNCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_SGN *SGNCaller) Paused(opts *bind.CallOpts) (bool, error)

type SGNCallerSession

+ func (_SGN *SGNCallerSession) IsOwner() (bool, error)

+ func (_SGN *SGNCallerSession) IsPauser(account common.Address) (bool, error)

+ func (_SGN *SGNCallerSession) Owner() (common.Address, error)

+ func (_SGN *SGNCallerSession) Paused() (bool, error)

type SGNFilterer

+ func (_SGN *SGNFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*SGNOwnershipTransferredIterator, error)

+ func (_SGN *SGNFilterer) FilterPaused(opts *bind.FilterOpts) (*SGNPausedIterator, error)

+ func (_SGN *SGNFilterer) FilterPauserAdded(opts *bind.FilterOpts, account []common.Address) (*SGNPauserAddedIterator, error)

+ func (_SGN *SGNFilterer) FilterPauserRemoved(opts *bind.FilterOpts, account []common.Address) (*SGNPauserRemovedIterator, error)

+ func (_SGN *SGNFilterer) FilterUnpaused(opts *bind.FilterOpts) (*SGNUnpausedIterator, error)

+ func (_SGN *SGNFilterer) ParseOwnershipTransferred(log types.Log) (*SGNOwnershipTransferred, error)

+ func (_SGN *SGNFilterer) ParsePaused(log types.Log) (*SGNPaused, error)

+ func (_SGN *SGNFilterer) ParsePauserAdded(log types.Log) (*SGNPauserAdded, error)

+ func (_SGN *SGNFilterer) ParsePauserRemoved(log types.Log) (*SGNPauserRemoved, error)

+ func (_SGN *SGNFilterer) ParseUnpaused(log types.Log) (*SGNUnpaused, error)

+ func (_SGN *SGNFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *SGNOwnershipTransferred, ...) (event.Subscription, error)

+ func (_SGN *SGNFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *SGNPaused) (event.Subscription, error)

+ func (_SGN *SGNFilterer) WatchPauserAdded(opts *bind.WatchOpts, sink chan<- *SGNPauserAdded, account []common.Address) (event.Subscription, error)

+ func (_SGN *SGNFilterer) WatchPauserRemoved(opts *bind.WatchOpts, sink chan<- *SGNPauserRemoved, account []common.Address) (event.Subscription, error)

+ func (_SGN *SGNFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *SGNUnpaused) (event.Subscription, error)

+ type SGNOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type SGNOwnershipTransferredIterator struct

+ Event *SGNOwnershipTransferred

+ func (it *SGNOwnershipTransferredIterator) Close() error

+ func (it *SGNOwnershipTransferredIterator) Error() error

+ func (it *SGNOwnershipTransferredIterator) Next() bool

+ type SGNPaused struct

+ Account common.Address

+ Raw types.Log

+ type SGNPausedIterator struct

+ Event *SGNPaused

+ func (it *SGNPausedIterator) Close() error

+ func (it *SGNPausedIterator) Error() error

+ func (it *SGNPausedIterator) Next() bool

+ type SGNPauserAdded struct

+ Account common.Address

+ Raw types.Log

+ type SGNPauserAddedIterator struct

+ Event *SGNPauserAdded

+ func (it *SGNPauserAddedIterator) Close() error

+ func (it *SGNPauserAddedIterator) Error() error

+ func (it *SGNPauserAddedIterator) Next() bool

+ type SGNPauserRemoved struct

+ Account common.Address

+ Raw types.Log

+ type SGNPauserRemovedIterator struct

+ Event *SGNPauserRemoved

+ func (it *SGNPauserRemovedIterator) Close() error

+ func (it *SGNPauserRemovedIterator) Error() error

+ func (it *SGNPauserRemovedIterator) Next() bool

type SGNSession

+ func (_SGN *SGNSession) AddPauser(account common.Address) (*types.Transaction, error)

+ func (_SGN *SGNSession) DrainToken(_amount *big.Int) (*types.Transaction, error)

+ func (_SGN *SGNSession) IsOwner() (bool, error)

+ func (_SGN *SGNSession) IsPauser(account common.Address) (bool, error)

+ func (_SGN *SGNSession) Owner() (common.Address, error)

+ func (_SGN *SGNSession) Pause() (*types.Transaction, error)

+ func (_SGN *SGNSession) Paused() (bool, error)

+ func (_SGN *SGNSession) RenounceOwnership() (*types.Transaction, error)

+ func (_SGN *SGNSession) RenouncePauser() (*types.Transaction, error)

+ func (_SGN *SGNSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_SGN *SGNSession) Unpause() (*types.Transaction, error)

type SGNTransactor

+ func (_SGN *SGNTransactor) AddPauser(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error)

+ func (_SGN *SGNTransactor) DrainToken(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error)

+ func (_SGN *SGNTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_SGN *SGNTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_SGN *SGNTransactor) RenouncePauser(opts *bind.TransactOpts) (*types.Transaction, error)

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

+ func (_SGN *SGNTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error)

type SGNTransactorSession

+ func (_SGN *SGNTransactorSession) AddPauser(account common.Address) (*types.Transaction, error)

+ func (_SGN *SGNTransactorSession) DrainToken(_amount *big.Int) (*types.Transaction, error)

+ func (_SGN *SGNTransactorSession) Pause() (*types.Transaction, error)

+ func (_SGN *SGNTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_SGN *SGNTransactorSession) RenouncePauser() (*types.Transaction, error)

+ func (_SGN *SGNTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_SGN *SGNTransactorSession) Unpause() (*types.Transaction, error)

+ type SGNUnpaused struct

+ Account common.Address

+ Raw types.Log

+ type SGNUnpausedIterator struct

+ Event *SGNUnpaused

+ func (it *SGNUnpausedIterator) Close() error

+ func (it *SGNUnpausedIterator) Error() error

+ func (it *SGNUnpausedIterator) Next() bool

type TransactorConfig

+ AddGasPriceGwei uint64

+ MinGasPriceGwei uint64

v0.2.0

Jul 15, 2020

Changes in this version

+ const BlameTimeout

+ const ChannelStatus_CLOSED

+ const ChannelStatus_MIGRATED

+ const ChannelStatus_OPERABLE

+ const ChannelStatus_SETTLING

+ const ChannelStatus_UNINITIALIZED

+ const DPoSABI

+ const GovernVoteTimeout

+ const IncreaseRateWaitTime

+ const MaxValidatorNum

+ const MinStakeInPool

+ const MinValidatorNum

+ const ProposalDeposit

+ const SGNABI

+ type DPoS struct

+ func DeployDPoS(auth *bind.TransactOpts, backend bind.ContractBackend, ...) (common.Address, *types.Transaction, *DPoS, error)

+ func NewDPoS(address common.Address, backend bind.ContractBackend) (*DPoS, error)

+ type DPoSCaller struct

+ func NewDPoSCaller(address common.Address, caller bind.ContractCaller) (*DPoSCaller, error)

+ func (_DPoS *DPoSCaller) COMMISSIONRATEBASE(opts *bind.CallOpts) (*big.Int, error)

+ func (_DPoS *DPoSCaller) CelerToken(opts *bind.CallOpts) (common.Address, error)

+ func (_DPoS *DPoSCaller) CheckedValidators(opts *bind.CallOpts, arg0 common.Address) (bool, error)

+ func (_DPoS *DPoSCaller) DposGoLiveTime(opts *bind.CallOpts) (*big.Int, error)

+ func (_DPoS *DPoSCaller) GetCandidateInfo(opts *bind.CallOpts, _candidateAddr common.Address) (struct{ ... }, error)

+ func (_DPoS *DPoSCaller) GetDelegatorInfo(opts *bind.CallOpts, _candidateAddr common.Address, ...) (struct{ ... }, error)

+ func (_DPoS *DPoSCaller) GetMinQuorumStakingPool(opts *bind.CallOpts) (*big.Int, error)

+ func (_DPoS *DPoSCaller) GetMinStakingPool(opts *bind.CallOpts) (*big.Int, error)

+ func (_DPoS *DPoSCaller) GetParamProposalVote(opts *bind.CallOpts, _proposalId *big.Int, _voter common.Address) (uint8, error)

+ func (_DPoS *DPoSCaller) GetSidechainProposalVote(opts *bind.CallOpts, _proposalId *big.Int, _voter common.Address) (uint8, error)

+ func (_DPoS *DPoSCaller) GetTotalValidatorStakingPool(opts *bind.CallOpts) (*big.Int, error)

+ func (_DPoS *DPoSCaller) GetUIntValue(opts *bind.CallOpts, _record *big.Int) (*big.Int, error)

+ func (_DPoS *DPoSCaller) GetValidatorNum(opts *bind.CallOpts) (*big.Int, error)

+ func (_DPoS *DPoSCaller) GovernToken(opts *bind.CallOpts) (common.Address, error)

+ func (_DPoS *DPoSCaller) IsOwner(opts *bind.CallOpts) (bool, error)

+ func (_DPoS *DPoSCaller) IsSidechainRegistered(opts *bind.CallOpts, _sidechainAddr common.Address) (bool, error)

+ func (_DPoS *DPoSCaller) IsValidDPoS(opts *bind.CallOpts) (bool, error)

+ func (_DPoS *DPoSCaller) IsValidator(opts *bind.CallOpts, _addr common.Address) (bool, error)

+ func (_DPoS *DPoSCaller) MiningPool(opts *bind.CallOpts) (*big.Int, error)

+ func (_DPoS *DPoSCaller) NextParamProposalId(opts *bind.CallOpts) (*big.Int, error)

+ func (_DPoS *DPoSCaller) NextSidechainProposalId(opts *bind.CallOpts) (*big.Int, error)

+ func (_DPoS *DPoSCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_DPoS *DPoSCaller) ParamProposals(opts *bind.CallOpts, arg0 *big.Int) (struct{ ... }, error)

+ func (_DPoS *DPoSCaller) RedeemedMiningReward(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_DPoS *DPoSCaller) RegisteredSidechains(opts *bind.CallOpts, arg0 common.Address) (bool, error)

+ func (_DPoS *DPoSCaller) SidechainProposals(opts *bind.CallOpts, arg0 *big.Int) (struct{ ... }, error)

+ func (_DPoS *DPoSCaller) UIntStorage(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error)

+ func (_DPoS *DPoSCaller) UsedPenaltyNonce(opts *bind.CallOpts, arg0 *big.Int) (bool, error)

+ func (_DPoS *DPoSCaller) ValidatorSet(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error)

+ type DPoSCallerRaw struct

+ Contract *DPoSCaller

+ func (_DPoS *DPoSCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type DPoSCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *DPoSCaller

+ func (_DPoS *DPoSCallerSession) COMMISSIONRATEBASE() (*big.Int, error)

+ func (_DPoS *DPoSCallerSession) CelerToken() (common.Address, error)

+ func (_DPoS *DPoSCallerSession) CheckedValidators(arg0 common.Address) (bool, error)

+ func (_DPoS *DPoSCallerSession) DposGoLiveTime() (*big.Int, error)

+ func (_DPoS *DPoSCallerSession) GetCandidateInfo(_candidateAddr common.Address) (struct{ ... }, error)

+ func (_DPoS *DPoSCallerSession) GetDelegatorInfo(_candidateAddr common.Address, _delegatorAddr common.Address) (struct{ ... }, error)

+ func (_DPoS *DPoSCallerSession) GetMinQuorumStakingPool() (*big.Int, error)

+ func (_DPoS *DPoSCallerSession) GetMinStakingPool() (*big.Int, error)

+ func (_DPoS *DPoSCallerSession) GetParamProposalVote(_proposalId *big.Int, _voter common.Address) (uint8, error)

+ func (_DPoS *DPoSCallerSession) GetSidechainProposalVote(_proposalId *big.Int, _voter common.Address) (uint8, error)

+ func (_DPoS *DPoSCallerSession) GetTotalValidatorStakingPool() (*big.Int, error)

+ func (_DPoS *DPoSCallerSession) GetUIntValue(_record *big.Int) (*big.Int, error)

+ func (_DPoS *DPoSCallerSession) GetValidatorNum() (*big.Int, error)

+ func (_DPoS *DPoSCallerSession) GovernToken() (common.Address, error)

+ func (_DPoS *DPoSCallerSession) IsOwner() (bool, error)

+ func (_DPoS *DPoSCallerSession) IsSidechainRegistered(_sidechainAddr common.Address) (bool, error)

+ func (_DPoS *DPoSCallerSession) IsValidDPoS() (bool, error)

+ func (_DPoS *DPoSCallerSession) IsValidator(_addr common.Address) (bool, error)

+ func (_DPoS *DPoSCallerSession) MiningPool() (*big.Int, error)

+ func (_DPoS *DPoSCallerSession) NextParamProposalId() (*big.Int, error)

+ func (_DPoS *DPoSCallerSession) NextSidechainProposalId() (*big.Int, error)

+ func (_DPoS *DPoSCallerSession) Owner() (common.Address, error)

+ func (_DPoS *DPoSCallerSession) ParamProposals(arg0 *big.Int) (struct{ ... }, error)

+ func (_DPoS *DPoSCallerSession) RedeemedMiningReward(arg0 common.Address) (*big.Int, error)

+ func (_DPoS *DPoSCallerSession) RegisteredSidechains(arg0 common.Address) (bool, error)

+ func (_DPoS *DPoSCallerSession) SidechainProposals(arg0 *big.Int) (struct{ ... }, error)

+ func (_DPoS *DPoSCallerSession) UIntStorage(arg0 *big.Int) (*big.Int, error)

+ func (_DPoS *DPoSCallerSession) UsedPenaltyNonce(arg0 *big.Int) (bool, error)

+ func (_DPoS *DPoSCallerSession) ValidatorSet(arg0 *big.Int) (common.Address, error)

+ type DPoSCandidateInfo struct

+ CommissionRate *big.Int

+ Initialized bool

+ MinSelfStake *big.Int

+ RateLockEndTime *big.Int

+ StakingPool *big.Int

+ Status *big.Int

+ UnbondTime *big.Int

+ type DPoSCandidateUnbonded struct

+ Candidate common.Address

+ Raw types.Log

+ type DPoSCandidateUnbondedIterator struct

+ Event *DPoSCandidateUnbonded

+ func (it *DPoSCandidateUnbondedIterator) Close() error

+ func (it *DPoSCandidateUnbondedIterator) Error() error

+ func (it *DPoSCandidateUnbondedIterator) Next() bool

+ type DPoSCommissionRateAnnouncement struct

+ AnnouncedLockEndTime *big.Int

+ AnnouncedRate *big.Int

+ Candidate common.Address

+ Raw types.Log

+ type DPoSCommissionRateAnnouncementIterator struct

+ Event *DPoSCommissionRateAnnouncement

+ func (it *DPoSCommissionRateAnnouncementIterator) Close() error

+ func (it *DPoSCommissionRateAnnouncementIterator) Error() error

+ func (it *DPoSCommissionRateAnnouncementIterator) Next() bool

+ type DPoSConfirmParamProposal struct

+ NewValue *big.Int

+ Passed bool

+ ProposalId *big.Int

+ Raw types.Log

+ Record *big.Int

+ type DPoSConfirmParamProposalIterator struct

+ Event *DPoSConfirmParamProposal

+ func (it *DPoSConfirmParamProposalIterator) Close() error

+ func (it *DPoSConfirmParamProposalIterator) Error() error

+ func (it *DPoSConfirmParamProposalIterator) Next() bool

+ type DPoSConfirmSidechainProposal struct

+ Passed bool

+ ProposalId *big.Int

+ Raw types.Log

+ Registered bool

+ SidechainAddr common.Address

+ type DPoSConfirmSidechainProposalIterator struct

+ Event *DPoSConfirmSidechainProposal

+ func (it *DPoSConfirmSidechainProposalIterator) Close() error

+ func (it *DPoSConfirmSidechainProposalIterator) Error() error

+ func (it *DPoSConfirmSidechainProposalIterator) Next() bool

+ type DPoSConfirmWithdraw struct

+ Amount *big.Int

+ Candidate common.Address

+ Delegator common.Address

+ Raw types.Log

+ type DPoSConfirmWithdrawIterator struct

+ Event *DPoSConfirmWithdraw

+ func (it *DPoSConfirmWithdrawIterator) Close() error

+ func (it *DPoSConfirmWithdrawIterator) Error() error

+ func (it *DPoSConfirmWithdrawIterator) Next() bool

+ type DPoSCreateParamProposal struct

+ Deposit *big.Int

+ NewValue *big.Int

+ ProposalId *big.Int

+ Proposer common.Address

+ Raw types.Log

+ Record *big.Int

+ VoteDeadline *big.Int

+ type DPoSCreateParamProposalIterator struct

+ Event *DPoSCreateParamProposal

+ func (it *DPoSCreateParamProposalIterator) Close() error

+ func (it *DPoSCreateParamProposalIterator) Error() error

+ func (it *DPoSCreateParamProposalIterator) Next() bool

+ type DPoSCreateSidechainProposal struct

+ Deposit *big.Int

+ ProposalId *big.Int

+ Proposer common.Address

+ Raw types.Log

+ Registered bool

+ SidechainAddr common.Address

+ VoteDeadline *big.Int

+ type DPoSCreateSidechainProposalIterator struct

+ Event *DPoSCreateSidechainProposal

+ func (it *DPoSCreateSidechainProposalIterator) Close() error

+ func (it *DPoSCreateSidechainProposalIterator) Error() error

+ func (it *DPoSCreateSidechainProposalIterator) Next() bool

+ type DPoSDelegate struct

+ Candidate common.Address

+ Delegator common.Address

+ NewStake *big.Int

+ Raw types.Log

+ StakingPool *big.Int

+ type DPoSDelegateIterator struct

+ Event *DPoSDelegate

+ func (it *DPoSDelegateIterator) Close() error

+ func (it *DPoSDelegateIterator) Error() error

+ func (it *DPoSDelegateIterator) Next() bool

+ type DPoSFilterer struct

+ func NewDPoSFilterer(address common.Address, filterer bind.ContractFilterer) (*DPoSFilterer, error)

+ func (_DPoS *DPoSFilterer) FilterCandidateUnbonded(opts *bind.FilterOpts, candidate []common.Address) (*DPoSCandidateUnbondedIterator, error)

+ func (_DPoS *DPoSFilterer) FilterCommissionRateAnnouncement(opts *bind.FilterOpts, candidate []common.Address) (*DPoSCommissionRateAnnouncementIterator, error)

+ func (_DPoS *DPoSFilterer) FilterConfirmParamProposal(opts *bind.FilterOpts) (*DPoSConfirmParamProposalIterator, error)

+ func (_DPoS *DPoSFilterer) FilterConfirmSidechainProposal(opts *bind.FilterOpts) (*DPoSConfirmSidechainProposalIterator, error)

+ func (_DPoS *DPoSFilterer) FilterConfirmWithdraw(opts *bind.FilterOpts, delegator []common.Address, candidate []common.Address) (*DPoSConfirmWithdrawIterator, error)

+ func (_DPoS *DPoSFilterer) FilterCreateParamProposal(opts *bind.FilterOpts) (*DPoSCreateParamProposalIterator, error)

+ func (_DPoS *DPoSFilterer) FilterCreateSidechainProposal(opts *bind.FilterOpts) (*DPoSCreateSidechainProposalIterator, error)

+ func (_DPoS *DPoSFilterer) FilterDelegate(opts *bind.FilterOpts, delegator []common.Address, candidate []common.Address) (*DPoSDelegateIterator, error)

+ func (_DPoS *DPoSFilterer) FilterIndemnify(opts *bind.FilterOpts, indemnitee []common.Address) (*DPoSIndemnifyIterator, error)

+ func (_DPoS *DPoSFilterer) FilterInitializeCandidate(opts *bind.FilterOpts, candidate []common.Address) (*DPoSInitializeCandidateIterator, error)

+ func (_DPoS *DPoSFilterer) FilterIntendWithdraw(opts *bind.FilterOpts, delegator []common.Address, candidate []common.Address) (*DPoSIntendWithdrawIterator, error)

+ func (_DPoS *DPoSFilterer) FilterMiningPoolContribution(opts *bind.FilterOpts, contributor []common.Address) (*DPoSMiningPoolContributionIterator, error)

+ func (_DPoS *DPoSFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*DPoSOwnershipTransferredIterator, error)

+ func (_DPoS *DPoSFilterer) FilterPunish(opts *bind.FilterOpts, validator []common.Address, delegator []common.Address) (*DPoSPunishIterator, error)

+ func (_DPoS *DPoSFilterer) FilterRedeemMiningReward(opts *bind.FilterOpts, receiver []common.Address) (*DPoSRedeemMiningRewardIterator, error)

+ func (_DPoS *DPoSFilterer) FilterUpdateCommissionRate(opts *bind.FilterOpts, candidate []common.Address) (*DPoSUpdateCommissionRateIterator, error)

+ func (_DPoS *DPoSFilterer) FilterValidatorChange(opts *bind.FilterOpts, ethAddr []common.Address, changeType []uint8) (*DPoSValidatorChangeIterator, error)

+ func (_DPoS *DPoSFilterer) FilterVoteParam(opts *bind.FilterOpts) (*DPoSVoteParamIterator, error)

+ func (_DPoS *DPoSFilterer) FilterVoteSidechain(opts *bind.FilterOpts) (*DPoSVoteSidechainIterator, error)

+ func (_DPoS *DPoSFilterer) FilterWithdrawFromUnbondedCandidate(opts *bind.FilterOpts, delegator []common.Address, candidate []common.Address) (*DPoSWithdrawFromUnbondedCandidateIterator, error)

+ func (_DPoS *DPoSFilterer) ParseCandidateUnbonded(log types.Log) (*DPoSCandidateUnbonded, error)

+ func (_DPoS *DPoSFilterer) ParseCommissionRateAnnouncement(log types.Log) (*DPoSCommissionRateAnnouncement, error)

+ func (_DPoS *DPoSFilterer) ParseConfirmParamProposal(log types.Log) (*DPoSConfirmParamProposal, error)

+ func (_DPoS *DPoSFilterer) ParseConfirmSidechainProposal(log types.Log) (*DPoSConfirmSidechainProposal, error)

+ func (_DPoS *DPoSFilterer) ParseConfirmWithdraw(log types.Log) (*DPoSConfirmWithdraw, error)

+ func (_DPoS *DPoSFilterer) ParseCreateParamProposal(log types.Log) (*DPoSCreateParamProposal, error)

+ func (_DPoS *DPoSFilterer) ParseCreateSidechainProposal(log types.Log) (*DPoSCreateSidechainProposal, error)

+ func (_DPoS *DPoSFilterer) ParseDelegate(log types.Log) (*DPoSDelegate, error)

+ func (_DPoS *DPoSFilterer) ParseIndemnify(log types.Log) (*DPoSIndemnify, error)

+ func (_DPoS *DPoSFilterer) ParseInitializeCandidate(log types.Log) (*DPoSInitializeCandidate, error)

+ func (_DPoS *DPoSFilterer) ParseIntendWithdraw(log types.Log) (*DPoSIntendWithdraw, error)

+ func (_DPoS *DPoSFilterer) ParseMiningPoolContribution(log types.Log) (*DPoSMiningPoolContribution, error)

+ func (_DPoS *DPoSFilterer) ParseOwnershipTransferred(log types.Log) (*DPoSOwnershipTransferred, error)

+ func (_DPoS *DPoSFilterer) ParsePunish(log types.Log) (*DPoSPunish, error)

+ func (_DPoS *DPoSFilterer) ParseRedeemMiningReward(log types.Log) (*DPoSRedeemMiningReward, error)

+ func (_DPoS *DPoSFilterer) ParseUpdateCommissionRate(log types.Log) (*DPoSUpdateCommissionRate, error)

+ func (_DPoS *DPoSFilterer) ParseValidatorChange(log types.Log) (*DPoSValidatorChange, error)

+ func (_DPoS *DPoSFilterer) ParseVoteParam(log types.Log) (*DPoSVoteParam, error)

+ func (_DPoS *DPoSFilterer) ParseVoteSidechain(log types.Log) (*DPoSVoteSidechain, error)

+ func (_DPoS *DPoSFilterer) ParseWithdrawFromUnbondedCandidate(log types.Log) (*DPoSWithdrawFromUnbondedCandidate, error)

+ func (_DPoS *DPoSFilterer) WatchCandidateUnbonded(opts *bind.WatchOpts, sink chan<- *DPoSCandidateUnbonded, ...) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchCommissionRateAnnouncement(opts *bind.WatchOpts, sink chan<- *DPoSCommissionRateAnnouncement, ...) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchConfirmParamProposal(opts *bind.WatchOpts, sink chan<- *DPoSConfirmParamProposal) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchConfirmSidechainProposal(opts *bind.WatchOpts, sink chan<- *DPoSConfirmSidechainProposal) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchConfirmWithdraw(opts *bind.WatchOpts, sink chan<- *DPoSConfirmWithdraw, ...) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchCreateParamProposal(opts *bind.WatchOpts, sink chan<- *DPoSCreateParamProposal) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchCreateSidechainProposal(opts *bind.WatchOpts, sink chan<- *DPoSCreateSidechainProposal) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchDelegate(opts *bind.WatchOpts, sink chan<- *DPoSDelegate, delegator []common.Address, ...) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchIndemnify(opts *bind.WatchOpts, sink chan<- *DPoSIndemnify, indemnitee []common.Address) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchInitializeCandidate(opts *bind.WatchOpts, sink chan<- *DPoSInitializeCandidate, ...) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchIntendWithdraw(opts *bind.WatchOpts, sink chan<- *DPoSIntendWithdraw, ...) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchMiningPoolContribution(opts *bind.WatchOpts, sink chan<- *DPoSMiningPoolContribution, ...) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *DPoSOwnershipTransferred, ...) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchPunish(opts *bind.WatchOpts, sink chan<- *DPoSPunish, validator []common.Address, ...) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchRedeemMiningReward(opts *bind.WatchOpts, sink chan<- *DPoSRedeemMiningReward, ...) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchUpdateCommissionRate(opts *bind.WatchOpts, sink chan<- *DPoSUpdateCommissionRate, ...) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchValidatorChange(opts *bind.WatchOpts, sink chan<- *DPoSValidatorChange, ...) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchVoteParam(opts *bind.WatchOpts, sink chan<- *DPoSVoteParam) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchVoteSidechain(opts *bind.WatchOpts, sink chan<- *DPoSVoteSidechain) (event.Subscription, error)

+ func (_DPoS *DPoSFilterer) WatchWithdrawFromUnbondedCandidate(opts *bind.WatchOpts, sink chan<- *DPoSWithdrawFromUnbondedCandidate, ...) (event.Subscription, error)

+ type DPoSIndemnify struct

+ Amount *big.Int

+ Indemnitee common.Address

+ Raw types.Log

+ type DPoSIndemnifyIterator struct

+ Event *DPoSIndemnify

+ func (it *DPoSIndemnifyIterator) Close() error

+ func (it *DPoSIndemnifyIterator) Error() error

+ func (it *DPoSIndemnifyIterator) Next() bool

+ type DPoSInitializeCandidate struct

+ Candidate common.Address

+ CommissionRate *big.Int

+ MinSelfStake *big.Int

+ RateLockEndTime *big.Int

+ Raw types.Log

+ type DPoSInitializeCandidateIterator struct

+ Event *DPoSInitializeCandidate

+ func (it *DPoSInitializeCandidateIterator) Close() error

+ func (it *DPoSInitializeCandidateIterator) Error() error

+ func (it *DPoSInitializeCandidateIterator) Next() bool

+ type DPoSIntendWithdraw struct

+ Candidate common.Address

+ Delegator common.Address

+ ProposedTime *big.Int

+ Raw types.Log

+ WithdrawAmount *big.Int

+ type DPoSIntendWithdrawIterator struct

+ Event *DPoSIntendWithdraw

+ func (it *DPoSIntendWithdrawIterator) Close() error

+ func (it *DPoSIntendWithdrawIterator) Error() error

+ func (it *DPoSIntendWithdrawIterator) Next() bool

+ type DPoSMiningPoolContribution struct

+ Contribution *big.Int

+ Contributor common.Address

+ MiningPoolSize *big.Int

+ Raw types.Log

+ type DPoSMiningPoolContributionIterator struct

+ Event *DPoSMiningPoolContribution

+ func (it *DPoSMiningPoolContributionIterator) Close() error

+ func (it *DPoSMiningPoolContributionIterator) Error() error

+ func (it *DPoSMiningPoolContributionIterator) Next() bool

+ type DPoSOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type DPoSOwnershipTransferredIterator struct

+ Event *DPoSOwnershipTransferred

+ func (it *DPoSOwnershipTransferredIterator) Close() error

+ func (it *DPoSOwnershipTransferredIterator) Error() error

+ func (it *DPoSOwnershipTransferredIterator) Next() bool

+ type DPoSPunish struct

+ Amount *big.Int

+ Delegator common.Address

+ Raw types.Log

+ Validator common.Address

+ type DPoSPunishIterator struct

+ Event *DPoSPunish

+ func (it *DPoSPunishIterator) Close() error

+ func (it *DPoSPunishIterator) Error() error

+ func (it *DPoSPunishIterator) Next() bool

+ type DPoSRaw struct

+ Contract *DPoS

+ func (_DPoS *DPoSRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_DPoS *DPoSRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DPoSRedeemMiningReward struct

+ MiningPool *big.Int

+ Raw types.Log

+ Receiver common.Address

+ Reward *big.Int

+ type DPoSRedeemMiningRewardIterator struct

+ Event *DPoSRedeemMiningReward

+ func (it *DPoSRedeemMiningRewardIterator) Close() error

+ func (it *DPoSRedeemMiningRewardIterator) Error() error

+ func (it *DPoSRedeemMiningRewardIterator) Next() bool

+ type DPoSSession struct

+ CallOpts bind.CallOpts

+ Contract *DPoS

+ TransactOpts bind.TransactOpts

+ func (_DPoS *DPoSSession) AnnounceIncreaseCommissionRate(_newRate *big.Int, _newLockEndTime *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) COMMISSIONRATEBASE() (*big.Int, error)

+ func (_DPoS *DPoSSession) CelerToken() (common.Address, error)

+ func (_DPoS *DPoSSession) CheckedValidators(arg0 common.Address) (bool, error)

+ func (_DPoS *DPoSSession) ClaimValidator() (*types.Transaction, error)

+ func (_DPoS *DPoSSession) ConfirmIncreaseCommissionRate() (*types.Transaction, error)

+ func (_DPoS *DPoSSession) ConfirmParamProposal(_proposalId *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) ConfirmSidechainProposal(_proposalId *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) ConfirmUnbondedCandidate(_candidateAddr common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) ConfirmWithdraw(_candidateAddr common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) ContributeToMiningPool(_amount *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) CreateParamProposal(_record *big.Int, _value *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) CreateSidechainProposal(_sidechainAddr common.Address, _registered bool) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) Delegate(_candidateAddr common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) DposGoLiveTime() (*big.Int, error)

+ func (_DPoS *DPoSSession) GetCandidateInfo(_candidateAddr common.Address) (struct{ ... }, error)

+ func (_DPoS *DPoSSession) GetDelegatorInfo(_candidateAddr common.Address, _delegatorAddr common.Address) (struct{ ... }, error)

+ func (_DPoS *DPoSSession) GetMinQuorumStakingPool() (*big.Int, error)

+ func (_DPoS *DPoSSession) GetMinStakingPool() (*big.Int, error)

+ func (_DPoS *DPoSSession) GetParamProposalVote(_proposalId *big.Int, _voter common.Address) (uint8, error)

+ func (_DPoS *DPoSSession) GetSidechainProposalVote(_proposalId *big.Int, _voter common.Address) (uint8, error)

+ func (_DPoS *DPoSSession) GetTotalValidatorStakingPool() (*big.Int, error)

+ func (_DPoS *DPoSSession) GetUIntValue(_record *big.Int) (*big.Int, error)

+ func (_DPoS *DPoSSession) GetValidatorNum() (*big.Int, error)

+ func (_DPoS *DPoSSession) GovernToken() (common.Address, error)

+ func (_DPoS *DPoSSession) InitializeCandidate(_minSelfStake *big.Int, _commissionRate *big.Int, _rateLockEndTime *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) IntendWithdraw(_candidateAddr common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) IsOwner() (bool, error)

+ func (_DPoS *DPoSSession) IsSidechainRegistered(_sidechainAddr common.Address) (bool, error)

+ func (_DPoS *DPoSSession) IsValidDPoS() (bool, error)

+ func (_DPoS *DPoSSession) IsValidator(_addr common.Address) (bool, error)

+ func (_DPoS *DPoSSession) MiningPool() (*big.Int, error)

+ func (_DPoS *DPoSSession) NextParamProposalId() (*big.Int, error)

+ func (_DPoS *DPoSSession) NextSidechainProposalId() (*big.Int, error)

+ func (_DPoS *DPoSSession) NonIncreaseCommissionRate(_newRate *big.Int, _newLockEndTime *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) Owner() (common.Address, error)

+ func (_DPoS *DPoSSession) ParamProposals(arg0 *big.Int) (struct{ ... }, error)

+ func (_DPoS *DPoSSession) Punish(_penaltyRequest []byte) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) RedeemMiningReward(_receiver common.Address, _cumulativeReward *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) RedeemedMiningReward(arg0 common.Address) (*big.Int, error)

+ func (_DPoS *DPoSSession) RegisterSidechain(_addr common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) RegisteredSidechains(arg0 common.Address) (bool, error)

+ func (_DPoS *DPoSSession) RenounceOwnership() (*types.Transaction, error)

+ func (_DPoS *DPoSSession) SidechainProposals(arg0 *big.Int) (struct{ ... }, error)

+ func (_DPoS *DPoSSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) UIntStorage(arg0 *big.Int) (*big.Int, error)

+ func (_DPoS *DPoSSession) UsedPenaltyNonce(arg0 *big.Int) (bool, error)

+ func (_DPoS *DPoSSession) ValidateMultiSigMessage(_request []byte) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) ValidatorSet(arg0 *big.Int) (common.Address, error)

+ func (_DPoS *DPoSSession) VoteParam(_proposalId *big.Int, _vote uint8) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) VoteSidechain(_proposalId *big.Int, _vote uint8) (*types.Transaction, error)

+ func (_DPoS *DPoSSession) WithdrawFromUnbondedCandidate(_candidateAddr common.Address, _amount *big.Int) (*types.Transaction, error)

+ type DPoSTransactor struct

+ func NewDPoSTransactor(address common.Address, transactor bind.ContractTransactor) (*DPoSTransactor, error)

+ func (_DPoS *DPoSTransactor) AnnounceIncreaseCommissionRate(opts *bind.TransactOpts, _newRate *big.Int, _newLockEndTime *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) ClaimValidator(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) ConfirmIncreaseCommissionRate(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) ConfirmParamProposal(opts *bind.TransactOpts, _proposalId *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) ConfirmSidechainProposal(opts *bind.TransactOpts, _proposalId *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) ConfirmUnbondedCandidate(opts *bind.TransactOpts, _candidateAddr common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) ConfirmWithdraw(opts *bind.TransactOpts, _candidateAddr common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) ContributeToMiningPool(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) CreateParamProposal(opts *bind.TransactOpts, _record *big.Int, _value *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) CreateSidechainProposal(opts *bind.TransactOpts, _sidechainAddr common.Address, _registered bool) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) Delegate(opts *bind.TransactOpts, _candidateAddr common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) InitializeCandidate(opts *bind.TransactOpts, _minSelfStake *big.Int, _commissionRate *big.Int, ...) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) IntendWithdraw(opts *bind.TransactOpts, _candidateAddr common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) NonIncreaseCommissionRate(opts *bind.TransactOpts, _newRate *big.Int, _newLockEndTime *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) Punish(opts *bind.TransactOpts, _penaltyRequest []byte) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) RedeemMiningReward(opts *bind.TransactOpts, _receiver common.Address, _cumulativeReward *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) RegisterSidechain(opts *bind.TransactOpts, _addr common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

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

+ func (_DPoS *DPoSTransactor) ValidateMultiSigMessage(opts *bind.TransactOpts, _request []byte) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) VoteParam(opts *bind.TransactOpts, _proposalId *big.Int, _vote uint8) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) VoteSidechain(opts *bind.TransactOpts, _proposalId *big.Int, _vote uint8) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactor) WithdrawFromUnbondedCandidate(opts *bind.TransactOpts, _candidateAddr common.Address, _amount *big.Int) (*types.Transaction, error)

+ type DPoSTransactorRaw struct

+ Contract *DPoSTransactor

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

+ func (_DPoS *DPoSTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DPoSTransactorSession struct

+ Contract *DPoSTransactor

+ TransactOpts bind.TransactOpts

+ func (_DPoS *DPoSTransactorSession) AnnounceIncreaseCommissionRate(_newRate *big.Int, _newLockEndTime *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) ClaimValidator() (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) ConfirmIncreaseCommissionRate() (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) ConfirmParamProposal(_proposalId *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) ConfirmSidechainProposal(_proposalId *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) ConfirmUnbondedCandidate(_candidateAddr common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) ConfirmWithdraw(_candidateAddr common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) ContributeToMiningPool(_amount *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) CreateParamProposal(_record *big.Int, _value *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) CreateSidechainProposal(_sidechainAddr common.Address, _registered bool) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) Delegate(_candidateAddr common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) InitializeCandidate(_minSelfStake *big.Int, _commissionRate *big.Int, _rateLockEndTime *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) IntendWithdraw(_candidateAddr common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) NonIncreaseCommissionRate(_newRate *big.Int, _newLockEndTime *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) Punish(_penaltyRequest []byte) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) RedeemMiningReward(_receiver common.Address, _cumulativeReward *big.Int) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) RegisterSidechain(_addr common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) ValidateMultiSigMessage(_request []byte) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) VoteParam(_proposalId *big.Int, _vote uint8) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) VoteSidechain(_proposalId *big.Int, _vote uint8) (*types.Transaction, error)

+ func (_DPoS *DPoSTransactorSession) WithdrawFromUnbondedCandidate(_candidateAddr common.Address, _amount *big.Int) (*types.Transaction, error)

+ type DPoSUpdateCommissionRate struct

+ Candidate common.Address

+ NewLockEndTime *big.Int

+ NewRate *big.Int

+ Raw types.Log

+ type DPoSUpdateCommissionRateIterator struct

+ Event *DPoSUpdateCommissionRate

+ func (it *DPoSUpdateCommissionRateIterator) Close() error

+ func (it *DPoSUpdateCommissionRateIterator) Error() error

+ func (it *DPoSUpdateCommissionRateIterator) Next() bool

+ type DPoSValidatorChange struct

+ ChangeType uint8

+ EthAddr common.Address

+ Raw types.Log

+ type DPoSValidatorChangeIterator struct

+ Event *DPoSValidatorChange

+ func (it *DPoSValidatorChangeIterator) Close() error

+ func (it *DPoSValidatorChangeIterator) Error() error

+ func (it *DPoSValidatorChangeIterator) Next() bool

+ type DPoSVoteParam struct

+ ProposalId *big.Int

+ Raw types.Log

+ VoteType uint8

+ Voter common.Address

+ type DPoSVoteParamIterator struct

+ Event *DPoSVoteParam

+ func (it *DPoSVoteParamIterator) Close() error

+ func (it *DPoSVoteParamIterator) Error() error

+ func (it *DPoSVoteParamIterator) Next() bool

+ type DPoSVoteSidechain struct

+ ProposalId *big.Int

+ Raw types.Log

+ VoteType uint8

+ Voter common.Address

+ type DPoSVoteSidechainIterator struct

+ Event *DPoSVoteSidechain

+ func (it *DPoSVoteSidechainIterator) Close() error

+ func (it *DPoSVoteSidechainIterator) Error() error

+ func (it *DPoSVoteSidechainIterator) Next() bool

+ type DPoSWithdrawFromUnbondedCandidate struct

+ Amount *big.Int

+ Candidate common.Address

+ Delegator common.Address

+ Raw types.Log

+ type DPoSWithdrawFromUnbondedCandidateIterator struct

+ Event *DPoSWithdrawFromUnbondedCandidate

+ func (it *DPoSWithdrawFromUnbondedCandidateIterator) Close() error

+ func (it *DPoSWithdrawFromUnbondedCandidateIterator) Error() error

+ func (it *DPoSWithdrawFromUnbondedCandidateIterator) Next() bool

type EthClient

+ DPoS *DPoS

+ DPoSAddress Addr

+ SGN *SGN

+ SGNAddress Addr

+ Signer eth.Signer

+ Transactor *eth.Transactor

+ func (ethClient *EthClient) SignEthMessage(data []byte) ([]byte, error)

+ type SGN struct

+ func DeploySGN(auth *bind.TransactOpts, backend bind.ContractBackend, ...) (common.Address, *types.Transaction, *SGN, error)

+ func NewSGN(address common.Address, backend bind.ContractBackend) (*SGN, error)

+ type SGNAddSubscriptionBalance struct

+ Amount *big.Int

+ Consumer common.Address

+ Raw types.Log

+ type SGNAddSubscriptionBalanceIterator struct

+ Event *SGNAddSubscriptionBalance

+ func (it *SGNAddSubscriptionBalanceIterator) Close() error

+ func (it *SGNAddSubscriptionBalanceIterator) Error() error

+ func (it *SGNAddSubscriptionBalanceIterator) Next() bool

+ type SGNCaller struct

+ func NewSGNCaller(address common.Address, caller bind.ContractCaller) (*SGNCaller, error)

+ func (_SGN *SGNCaller) CelerToken(opts *bind.CallOpts) (common.Address, error)

+ func (_SGN *SGNCaller) DPoSContract(opts *bind.CallOpts) (common.Address, error)

+ func (_SGN *SGNCaller) RedeemedServiceReward(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_SGN *SGNCaller) ServicePool(opts *bind.CallOpts) (*big.Int, error)

+ func (_SGN *SGNCaller) SidechainAddrMap(opts *bind.CallOpts, arg0 common.Address) ([]byte, error)

+ func (_SGN *SGNCaller) SubscriptionDeposits(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ type SGNCallerRaw struct

+ Contract *SGNCaller

+ func (_SGN *SGNCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type SGNCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SGNCaller

+ func (_SGN *SGNCallerSession) CelerToken() (common.Address, error)

+ func (_SGN *SGNCallerSession) DPoSContract() (common.Address, error)

+ func (_SGN *SGNCallerSession) RedeemedServiceReward(arg0 common.Address) (*big.Int, error)

+ func (_SGN *SGNCallerSession) ServicePool() (*big.Int, error)

+ func (_SGN *SGNCallerSession) SidechainAddrMap(arg0 common.Address) ([]byte, error)

+ func (_SGN *SGNCallerSession) SubscriptionDeposits(arg0 common.Address) (*big.Int, error)

+ type SGNFilterer struct

+ func NewSGNFilterer(address common.Address, filterer bind.ContractFilterer) (*SGNFilterer, error)

+ func (_SGN *SGNFilterer) FilterAddSubscriptionBalance(opts *bind.FilterOpts, consumer []common.Address) (*SGNAddSubscriptionBalanceIterator, error)

+ func (_SGN *SGNFilterer) FilterRedeemReward(opts *bind.FilterOpts, receiver []common.Address) (*SGNRedeemRewardIterator, error)

+ func (_SGN *SGNFilterer) FilterUpdateSidechainAddr(opts *bind.FilterOpts, candidate []common.Address, oldSidechainAddr [][]byte, ...) (*SGNUpdateSidechainAddrIterator, error)

+ func (_SGN *SGNFilterer) ParseAddSubscriptionBalance(log types.Log) (*SGNAddSubscriptionBalance, error)

+ func (_SGN *SGNFilterer) ParseRedeemReward(log types.Log) (*SGNRedeemReward, error)

+ func (_SGN *SGNFilterer) ParseUpdateSidechainAddr(log types.Log) (*SGNUpdateSidechainAddr, error)

+ func (_SGN *SGNFilterer) WatchAddSubscriptionBalance(opts *bind.WatchOpts, sink chan<- *SGNAddSubscriptionBalance, ...) (event.Subscription, error)

+ func (_SGN *SGNFilterer) WatchRedeemReward(opts *bind.WatchOpts, sink chan<- *SGNRedeemReward, receiver []common.Address) (event.Subscription, error)

+ func (_SGN *SGNFilterer) WatchUpdateSidechainAddr(opts *bind.WatchOpts, sink chan<- *SGNUpdateSidechainAddr, ...) (event.Subscription, error)

+ type SGNRaw struct

+ Contract *SGN

+ func (_SGN *SGNRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_SGN *SGNRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SGNRedeemReward struct

+ CumulativeMiningReward *big.Int

+ Raw types.Log

+ Receiver common.Address

+ ServicePool *big.Int

+ ServiceReward *big.Int

+ type SGNRedeemRewardIterator struct

+ Event *SGNRedeemReward

+ func (it *SGNRedeemRewardIterator) Close() error

+ func (it *SGNRedeemRewardIterator) Error() error

+ func (it *SGNRedeemRewardIterator) Next() bool

+ type SGNSession struct

+ CallOpts bind.CallOpts

+ Contract *SGN

+ TransactOpts bind.TransactOpts

+ func (_SGN *SGNSession) CelerToken() (common.Address, error)

+ func (_SGN *SGNSession) DPoSContract() (common.Address, error)

+ func (_SGN *SGNSession) RedeemReward(_rewardRequest []byte) (*types.Transaction, error)

+ func (_SGN *SGNSession) RedeemedServiceReward(arg0 common.Address) (*big.Int, error)

+ func (_SGN *SGNSession) ServicePool() (*big.Int, error)

+ func (_SGN *SGNSession) SidechainAddrMap(arg0 common.Address) ([]byte, error)

+ func (_SGN *SGNSession) Subscribe(_amount *big.Int) (*types.Transaction, error)

+ func (_SGN *SGNSession) SubscriptionDeposits(arg0 common.Address) (*big.Int, error)

+ func (_SGN *SGNSession) UpdateSidechainAddr(_sidechainAddr []byte) (*types.Transaction, error)

+ type SGNTransactor struct

+ func NewSGNTransactor(address common.Address, transactor bind.ContractTransactor) (*SGNTransactor, error)

+ func (_SGN *SGNTransactor) RedeemReward(opts *bind.TransactOpts, _rewardRequest []byte) (*types.Transaction, error)

+ func (_SGN *SGNTransactor) Subscribe(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error)

+ func (_SGN *SGNTransactor) UpdateSidechainAddr(opts *bind.TransactOpts, _sidechainAddr []byte) (*types.Transaction, error)

+ type SGNTransactorRaw struct

+ Contract *SGNTransactor

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

+ func (_SGN *SGNTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SGNTransactorSession struct

+ Contract *SGNTransactor

+ TransactOpts bind.TransactOpts

+ func (_SGN *SGNTransactorSession) RedeemReward(_rewardRequest []byte) (*types.Transaction, error)

+ func (_SGN *SGNTransactorSession) Subscribe(_amount *big.Int) (*types.Transaction, error)

+ func (_SGN *SGNTransactorSession) UpdateSidechainAddr(_sidechainAddr []byte) (*types.Transaction, error)

+ type SGNUpdateSidechainAddr struct

+ Candidate common.Address

+ NewSidechainAddr common.Hash

+ OldSidechainAddr common.Hash

+ Raw types.Log

+ type SGNUpdateSidechainAddrIterator struct

+ Event *SGNUpdateSidechainAddr

+ func (it *SGNUpdateSidechainAddrIterator) Close() error

+ func (it *SGNUpdateSidechainAddrIterator) Error() error

+ func (it *SGNUpdateSidechainAddrIterator) Next() bool

+ type SidechainAddr = []byte

+ type TransactorConfig struct

+ BlockDelay uint64

+ BlockPollingInterval uint64

+ ChainId *big.Int

v0.1.0

Feb 14, 2020

Changes in this version

+ const AddValidator

+ const Bonded

+ const CelerLedgerABI

+ const ClosedChannel

+ const ERC20ABI

+ const ERC20Bin

+ const ERC20InterfaceABI

+ const ERC20InterfaceBin

+ const GuardABI

+ const MigratedChannel

+ const OperableChannel

+ const RemoveValidator

+ const SettlingChannel

+ const TxFailure

+ const TxSuccess

+ const Unbonded

+ const Unbonding

+ const UninitializedChannel

+ var CelerLedgerBin = ""

+ var ZeroAddr Addr

+ var ZeroAddrHex = Addr2Hex(ZeroAddr)

+ var ZeroBigInt = big.NewInt(0)

+ var ZeroCid CidType

+ func Addr2Hex(a Addr) string

+ func Bytes2AddrHex(b []byte) string

+ func Bytes2Hex(b []byte) string

+ func Cid2Hex(p CidType) string

+ func FormatAddrHex(s string) string

+ func GetTxSender(ec *ethclient.Client, txHashStr string) (string, error)

+ func Hex2Bytes(s string) (b []byte)

+ func IsBonded(candidateInfo CandidateInfo) bool

+ func ParseStatus(candidateInfo CandidateInfo) sdk.BondStatus

+ func SignMessage(privateKey *ecdsa.PrivateKey, data []byte) ([]byte, error)

+ func WaitMined(ctx context.Context, ec *ethclient.Client, tx *ethtypes.Transaction, ...) (*ethtypes.Receipt, error)

+ func WaitMinedWithTxHash(ctx context.Context, ec *ethclient.Client, txHash string, blockDelay uint64) (*ethtypes.Receipt, error)

+ type Addr = ec.Address

+ func Bytes2Addr(b []byte) Addr

+ func Hex2Addr(s string) Addr

+ func RecoverSigner(data []byte, sig []byte) (Addr, error)

+ type CandidateInfo struct

+ Initialized bool

+ MinSelfStake *big.Int

+ SidechainAddr []byte

+ StakingPool *big.Int

+ Status *big.Int

+ UnbondTime *big.Int

+ type CelerLedger struct

+ func DeployCelerLedger(auth *bind.TransactOpts, backend bind.ContractBackend, _ethPool common.Address, ...) (common.Address, *types.Transaction, *CelerLedger, error)

+ func NewCelerLedger(address common.Address, backend bind.ContractBackend) (*CelerLedger, error)

+ type CelerLedgerCaller struct

+ func NewCelerLedgerCaller(address common.Address, caller bind.ContractCaller) (*CelerLedgerCaller, error)

+ func (_CelerLedger *CelerLedgerCaller) GetBalanceLimit(opts *bind.CallOpts, _tokenAddr common.Address) (*big.Int, error)

+ func (_CelerLedger *CelerLedgerCaller) GetBalanceLimitsEnabled(opts *bind.CallOpts) (bool, error)

+ func (_CelerLedger *CelerLedgerCaller) GetBalanceMap(opts *bind.CallOpts, _channelId [32]byte) ([2]common.Address, [2]*big.Int, [2]*big.Int, error)

+ func (_CelerLedger *CelerLedgerCaller) GetCelerWallet(opts *bind.CallOpts) (common.Address, error)

+ func (_CelerLedger *CelerLedgerCaller) GetChannelMigrationArgs(opts *bind.CallOpts, _channelId [32]byte) (*big.Int, *big.Int, common.Address, *big.Int, error)

+ func (_CelerLedger *CelerLedgerCaller) GetChannelStatus(opts *bind.CallOpts, _channelId [32]byte) (uint8, error)

+ func (_CelerLedger *CelerLedgerCaller) GetChannelStatusNum(opts *bind.CallOpts, _channelStatus *big.Int) (*big.Int, error)

+ func (_CelerLedger *CelerLedgerCaller) GetCooperativeWithdrawSeqNum(opts *bind.CallOpts, _channelId [32]byte) (*big.Int, error)

+ func (_CelerLedger *CelerLedgerCaller) GetDisputeTimeout(opts *bind.CallOpts, _channelId [32]byte) (*big.Int, error)

+ func (_CelerLedger *CelerLedgerCaller) GetEthPool(opts *bind.CallOpts) (common.Address, error)

+ func (_CelerLedger *CelerLedgerCaller) GetLastPayResolveDeadlineMap(opts *bind.CallOpts, _channelId [32]byte) ([2]common.Address, [2]*big.Int, error)

+ func (_CelerLedger *CelerLedgerCaller) GetMigratedTo(opts *bind.CallOpts, _channelId [32]byte) (common.Address, error)

+ func (_CelerLedger *CelerLedgerCaller) GetNextPayIdListHashMap(opts *bind.CallOpts, _channelId [32]byte) ([2]common.Address, [2][32]byte, error)

+ func (_CelerLedger *CelerLedgerCaller) GetPayRegistry(opts *bind.CallOpts) (common.Address, error)

+ func (_CelerLedger *CelerLedgerCaller) GetPeersMigrationInfo(opts *bind.CallOpts, _channelId [32]byte) ([2]common.Address, [2]*big.Int, [2]*big.Int, [2]*big.Int, [2]*big.Int, ...)

+ func (_CelerLedger *CelerLedgerCaller) GetPendingPayOutMap(opts *bind.CallOpts, _channelId [32]byte) ([2]common.Address, [2]*big.Int, error)

+ func (_CelerLedger *CelerLedgerCaller) GetSettleFinalizedTime(opts *bind.CallOpts, _channelId [32]byte) (*big.Int, error)

+ func (_CelerLedger *CelerLedgerCaller) GetStateSeqNumMap(opts *bind.CallOpts, _channelId [32]byte) ([2]common.Address, [2]*big.Int, error)

+ func (_CelerLedger *CelerLedgerCaller) GetTokenContract(opts *bind.CallOpts, _channelId [32]byte) (common.Address, error)

+ func (_CelerLedger *CelerLedgerCaller) GetTokenType(opts *bind.CallOpts, _channelId [32]byte) (uint8, error)

+ func (_CelerLedger *CelerLedgerCaller) GetTotalBalance(opts *bind.CallOpts, _channelId [32]byte) (*big.Int, error)

+ func (_CelerLedger *CelerLedgerCaller) GetTransferOutMap(opts *bind.CallOpts, _channelId [32]byte) ([2]common.Address, [2]*big.Int, error)

+ func (_CelerLedger *CelerLedgerCaller) GetWithdrawIntent(opts *bind.CallOpts, _channelId [32]byte) (common.Address, *big.Int, *big.Int, [32]byte, error)

+ func (_CelerLedger *CelerLedgerCaller) IsOwner(opts *bind.CallOpts) (bool, error)

+ func (_CelerLedger *CelerLedgerCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ type CelerLedgerCallerRaw struct

+ Contract *CelerLedgerCaller

+ func (_CelerLedger *CelerLedgerCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type CelerLedgerCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *CelerLedgerCaller

+ func (_CelerLedger *CelerLedgerCallerSession) GetBalanceLimit(_tokenAddr common.Address) (*big.Int, error)

+ func (_CelerLedger *CelerLedgerCallerSession) GetBalanceLimitsEnabled() (bool, error)

+ func (_CelerLedger *CelerLedgerCallerSession) GetBalanceMap(_channelId [32]byte) ([2]common.Address, [2]*big.Int, [2]*big.Int, error)

+ func (_CelerLedger *CelerLedgerCallerSession) GetCelerWallet() (common.Address, error)

+ func (_CelerLedger *CelerLedgerCallerSession) GetChannelMigrationArgs(_channelId [32]byte) (*big.Int, *big.Int, common.Address, *big.Int, error)

+ func (_CelerLedger *CelerLedgerCallerSession) GetChannelStatus(_channelId [32]byte) (uint8, error)

+ func (_CelerLedger *CelerLedgerCallerSession) GetChannelStatusNum(_channelStatus *big.Int) (*big.Int, error)

+ func (_CelerLedger *CelerLedgerCallerSession) GetCooperativeWithdrawSeqNum(_channelId [32]byte) (*big.Int, error)

+ func (_CelerLedger *CelerLedgerCallerSession) GetDisputeTimeout(_channelId [32]byte) (*big.Int, error)

+ func (_CelerLedger *CelerLedgerCallerSession) GetEthPool() (common.Address, error)

+ func (_CelerLedger *CelerLedgerCallerSession) GetLastPayResolveDeadlineMap(_channelId [32]byte) ([2]common.Address, [2]*big.Int, error)

+ func (_CelerLedger *CelerLedgerCallerSession) GetMigratedTo(_channelId [32]byte) (common.Address, error)

+ func (_CelerLedger *CelerLedgerCallerSession) GetNextPayIdListHashMap(_channelId [32]byte) ([2]common.Address, [2][32]byte, error)

+ func (_CelerLedger *CelerLedgerCallerSession) GetPayRegistry() (common.Address, error)

+ func (_CelerLedger *CelerLedgerCallerSession) GetPeersMigrationInfo(_channelId [32]byte) ([2]common.Address, [2]*big.Int, [2]*big.Int, [2]*big.Int, [2]*big.Int, ...)

+ func (_CelerLedger *CelerLedgerCallerSession) GetPendingPayOutMap(_channelId [32]byte) ([2]common.Address, [2]*big.Int, error)

+ func (_CelerLedger *CelerLedgerCallerSession) GetSettleFinalizedTime(_channelId [32]byte) (*big.Int, error)

+ func (_CelerLedger *CelerLedgerCallerSession) GetStateSeqNumMap(_channelId [32]byte) ([2]common.Address, [2]*big.Int, error)

+ func (_CelerLedger *CelerLedgerCallerSession) GetTokenContract(_channelId [32]byte) (common.Address, error)

+ func (_CelerLedger *CelerLedgerCallerSession) GetTokenType(_channelId [32]byte) (uint8, error)

+ func (_CelerLedger *CelerLedgerCallerSession) GetTotalBalance(_channelId [32]byte) (*big.Int, error)

+ func (_CelerLedger *CelerLedgerCallerSession) GetTransferOutMap(_channelId [32]byte) ([2]common.Address, [2]*big.Int, error)

+ func (_CelerLedger *CelerLedgerCallerSession) GetWithdrawIntent(_channelId [32]byte) (common.Address, *big.Int, *big.Int, [32]byte, error)

+ func (_CelerLedger *CelerLedgerCallerSession) IsOwner() (bool, error)

+ func (_CelerLedger *CelerLedgerCallerSession) Owner() (common.Address, error)

+ type CelerLedgerClearOnePay struct

+ Amount *big.Int

+ ChannelId [32]byte

+ PayId [32]byte

+ PeerFrom common.Address

+ Raw types.Log

+ type CelerLedgerClearOnePayIterator struct

+ Event *CelerLedgerClearOnePay

+ func (it *CelerLedgerClearOnePayIterator) Close() error

+ func (it *CelerLedgerClearOnePayIterator) Error() error

+ func (it *CelerLedgerClearOnePayIterator) Next() bool

+ type CelerLedgerConfirmSettle struct

+ ChannelId [32]byte

+ Raw types.Log

+ SettleBalance [2]*big.Int

+ type CelerLedgerConfirmSettleFail struct

+ ChannelId [32]byte

+ Raw types.Log

+ type CelerLedgerConfirmSettleFailIterator struct

+ Event *CelerLedgerConfirmSettleFail

+ func (it *CelerLedgerConfirmSettleFailIterator) Close() error

+ func (it *CelerLedgerConfirmSettleFailIterator) Error() error

+ func (it *CelerLedgerConfirmSettleFailIterator) Next() bool

+ type CelerLedgerConfirmSettleIterator struct

+ Event *CelerLedgerConfirmSettle

+ func (it *CelerLedgerConfirmSettleIterator) Close() error

+ func (it *CelerLedgerConfirmSettleIterator) Error() error

+ func (it *CelerLedgerConfirmSettleIterator) Next() bool

+ type CelerLedgerConfirmWithdraw struct

+ ChannelId [32]byte

+ Deposits [2]*big.Int

+ Raw types.Log

+ Receiver common.Address

+ RecipientChannelId [32]byte

+ Withdrawals [2]*big.Int

+ WithdrawnAmount *big.Int

+ type CelerLedgerConfirmWithdrawIterator struct

+ Event *CelerLedgerConfirmWithdraw

+ func (it *CelerLedgerConfirmWithdrawIterator) Close() error

+ func (it *CelerLedgerConfirmWithdrawIterator) Error() error

+ func (it *CelerLedgerConfirmWithdrawIterator) Next() bool

+ type CelerLedgerCooperativeSettle struct

+ ChannelId [32]byte

+ Raw types.Log

+ SettleBalance [2]*big.Int

+ type CelerLedgerCooperativeSettleIterator struct

+ Event *CelerLedgerCooperativeSettle

+ func (it *CelerLedgerCooperativeSettleIterator) Close() error

+ func (it *CelerLedgerCooperativeSettleIterator) Error() error

+ func (it *CelerLedgerCooperativeSettleIterator) Next() bool

+ type CelerLedgerCooperativeWithdraw struct

+ ChannelId [32]byte

+ Deposits [2]*big.Int

+ Raw types.Log

+ Receiver common.Address

+ RecipientChannelId [32]byte

+ SeqNum *big.Int

+ Withdrawals [2]*big.Int

+ WithdrawnAmount *big.Int

+ type CelerLedgerCooperativeWithdrawIterator struct

+ Event *CelerLedgerCooperativeWithdraw

+ func (it *CelerLedgerCooperativeWithdrawIterator) Close() error

+ func (it *CelerLedgerCooperativeWithdrawIterator) Error() error

+ func (it *CelerLedgerCooperativeWithdrawIterator) Next() bool

+ type CelerLedgerDeposit struct

+ ChannelId [32]byte

+ Deposits [2]*big.Int

+ PeerAddrs [2]common.Address

+ Raw types.Log

+ Withdrawals [2]*big.Int

+ type CelerLedgerDepositIterator struct

+ Event *CelerLedgerDeposit

+ func (it *CelerLedgerDepositIterator) Close() error

+ func (it *CelerLedgerDepositIterator) Error() error

+ func (it *CelerLedgerDepositIterator) Next() bool

+ type CelerLedgerFilterer struct

+ func NewCelerLedgerFilterer(address common.Address, filterer bind.ContractFilterer) (*CelerLedgerFilterer, error)

+ func (_CelerLedger *CelerLedgerFilterer) FilterClearOnePay(opts *bind.FilterOpts, channelId [][32]byte, payId [][32]byte, ...) (*CelerLedgerClearOnePayIterator, error)

+ func (_CelerLedger *CelerLedgerFilterer) FilterConfirmSettle(opts *bind.FilterOpts, channelId [][32]byte) (*CelerLedgerConfirmSettleIterator, error)

+ func (_CelerLedger *CelerLedgerFilterer) FilterConfirmSettleFail(opts *bind.FilterOpts, channelId [][32]byte) (*CelerLedgerConfirmSettleFailIterator, error)

+ func (_CelerLedger *CelerLedgerFilterer) FilterConfirmWithdraw(opts *bind.FilterOpts, channelId [][32]byte, receiver []common.Address, ...) (*CelerLedgerConfirmWithdrawIterator, error)

+ func (_CelerLedger *CelerLedgerFilterer) FilterCooperativeSettle(opts *bind.FilterOpts, channelId [][32]byte) (*CelerLedgerCooperativeSettleIterator, error)

+ func (_CelerLedger *CelerLedgerFilterer) FilterCooperativeWithdraw(opts *bind.FilterOpts, channelId [][32]byte, receiver []common.Address, ...) (*CelerLedgerCooperativeWithdrawIterator, error)

+ func (_CelerLedger *CelerLedgerFilterer) FilterDeposit(opts *bind.FilterOpts, channelId [][32]byte) (*CelerLedgerDepositIterator, error)

+ func (_CelerLedger *CelerLedgerFilterer) FilterIntendSettle(opts *bind.FilterOpts, channelId [][32]byte) (*CelerLedgerIntendSettleIterator, error)

+ func (_CelerLedger *CelerLedgerFilterer) FilterIntendWithdraw(opts *bind.FilterOpts, channelId [][32]byte, receiver []common.Address) (*CelerLedgerIntendWithdrawIterator, error)

+ func (_CelerLedger *CelerLedgerFilterer) FilterMigrateChannelFrom(opts *bind.FilterOpts, channelId [][32]byte, oldLedgerAddr []common.Address) (*CelerLedgerMigrateChannelFromIterator, error)

+ func (_CelerLedger *CelerLedgerFilterer) FilterMigrateChannelTo(opts *bind.FilterOpts, channelId [][32]byte, newLedgerAddr []common.Address) (*CelerLedgerMigrateChannelToIterator, error)

+ func (_CelerLedger *CelerLedgerFilterer) FilterOpenChannel(opts *bind.FilterOpts, channelId [][32]byte, tokenAddress []common.Address) (*CelerLedgerOpenChannelIterator, error)

+ func (_CelerLedger *CelerLedgerFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*CelerLedgerOwnershipTransferredIterator, error)

+ func (_CelerLedger *CelerLedgerFilterer) FilterSnapshotStates(opts *bind.FilterOpts, channelId [][32]byte) (*CelerLedgerSnapshotStatesIterator, error)

+ func (_CelerLedger *CelerLedgerFilterer) FilterVetoWithdraw(opts *bind.FilterOpts, channelId [][32]byte) (*CelerLedgerVetoWithdrawIterator, error)

+ func (_CelerLedger *CelerLedgerFilterer) ParseClearOnePay(log types.Log) (*CelerLedgerClearOnePay, error)

+ func (_CelerLedger *CelerLedgerFilterer) ParseConfirmSettle(log types.Log) (*CelerLedgerConfirmSettle, error)

+ func (_CelerLedger *CelerLedgerFilterer) ParseConfirmSettleFail(log types.Log) (*CelerLedgerConfirmSettleFail, error)

+ func (_CelerLedger *CelerLedgerFilterer) ParseConfirmWithdraw(log types.Log) (*CelerLedgerConfirmWithdraw, error)

+ func (_CelerLedger *CelerLedgerFilterer) ParseCooperativeSettle(log types.Log) (*CelerLedgerCooperativeSettle, error)

+ func (_CelerLedger *CelerLedgerFilterer) ParseCooperativeWithdraw(log types.Log) (*CelerLedgerCooperativeWithdraw, error)

+ func (_CelerLedger *CelerLedgerFilterer) ParseDeposit(log types.Log) (*CelerLedgerDeposit, error)

+ func (_CelerLedger *CelerLedgerFilterer) ParseIntendSettle(log types.Log) (*CelerLedgerIntendSettle, error)

+ func (_CelerLedger *CelerLedgerFilterer) ParseIntendWithdraw(log types.Log) (*CelerLedgerIntendWithdraw, error)

+ func (_CelerLedger *CelerLedgerFilterer) ParseMigrateChannelFrom(log types.Log) (*CelerLedgerMigrateChannelFrom, error)

+ func (_CelerLedger *CelerLedgerFilterer) ParseMigrateChannelTo(log types.Log) (*CelerLedgerMigrateChannelTo, error)

+ func (_CelerLedger *CelerLedgerFilterer) ParseOpenChannel(log types.Log) (*CelerLedgerOpenChannel, error)

+ func (_CelerLedger *CelerLedgerFilterer) ParseOwnershipTransferred(log types.Log) (*CelerLedgerOwnershipTransferred, error)

+ func (_CelerLedger *CelerLedgerFilterer) ParseSnapshotStates(log types.Log) (*CelerLedgerSnapshotStates, error)

+ func (_CelerLedger *CelerLedgerFilterer) ParseVetoWithdraw(log types.Log) (*CelerLedgerVetoWithdraw, error)

+ func (_CelerLedger *CelerLedgerFilterer) WatchClearOnePay(opts *bind.WatchOpts, sink chan<- *CelerLedgerClearOnePay, ...) (event.Subscription, error)

+ func (_CelerLedger *CelerLedgerFilterer) WatchConfirmSettle(opts *bind.WatchOpts, sink chan<- *CelerLedgerConfirmSettle, ...) (event.Subscription, error)

+ func (_CelerLedger *CelerLedgerFilterer) WatchConfirmSettleFail(opts *bind.WatchOpts, sink chan<- *CelerLedgerConfirmSettleFail, ...) (event.Subscription, error)

+ func (_CelerLedger *CelerLedgerFilterer) WatchConfirmWithdraw(opts *bind.WatchOpts, sink chan<- *CelerLedgerConfirmWithdraw, ...) (event.Subscription, error)

+ func (_CelerLedger *CelerLedgerFilterer) WatchCooperativeSettle(opts *bind.WatchOpts, sink chan<- *CelerLedgerCooperativeSettle, ...) (event.Subscription, error)

+ func (_CelerLedger *CelerLedgerFilterer) WatchCooperativeWithdraw(opts *bind.WatchOpts, sink chan<- *CelerLedgerCooperativeWithdraw, ...) (event.Subscription, error)

+ func (_CelerLedger *CelerLedgerFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *CelerLedgerDeposit, channelId [][32]byte) (event.Subscription, error)

+ func (_CelerLedger *CelerLedgerFilterer) WatchIntendSettle(opts *bind.WatchOpts, sink chan<- *CelerLedgerIntendSettle, ...) (event.Subscription, error)

+ func (_CelerLedger *CelerLedgerFilterer) WatchIntendWithdraw(opts *bind.WatchOpts, sink chan<- *CelerLedgerIntendWithdraw, ...) (event.Subscription, error)

+ func (_CelerLedger *CelerLedgerFilterer) WatchMigrateChannelFrom(opts *bind.WatchOpts, sink chan<- *CelerLedgerMigrateChannelFrom, ...) (event.Subscription, error)

+ func (_CelerLedger *CelerLedgerFilterer) WatchMigrateChannelTo(opts *bind.WatchOpts, sink chan<- *CelerLedgerMigrateChannelTo, ...) (event.Subscription, error)

+ func (_CelerLedger *CelerLedgerFilterer) WatchOpenChannel(opts *bind.WatchOpts, sink chan<- *CelerLedgerOpenChannel, ...) (event.Subscription, error)

+ func (_CelerLedger *CelerLedgerFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *CelerLedgerOwnershipTransferred, ...) (event.Subscription, error)

+ func (_CelerLedger *CelerLedgerFilterer) WatchSnapshotStates(opts *bind.WatchOpts, sink chan<- *CelerLedgerSnapshotStates, ...) (event.Subscription, error)

+ func (_CelerLedger *CelerLedgerFilterer) WatchVetoWithdraw(opts *bind.WatchOpts, sink chan<- *CelerLedgerVetoWithdraw, ...) (event.Subscription, error)

+ type CelerLedgerIntendSettle struct

+ ChannelId [32]byte

+ Raw types.Log

+ SeqNums [2]*big.Int

+ type CelerLedgerIntendSettleIterator struct

+ Event *CelerLedgerIntendSettle

+ func (it *CelerLedgerIntendSettleIterator) Close() error

+ func (it *CelerLedgerIntendSettleIterator) Error() error

+ func (it *CelerLedgerIntendSettleIterator) Next() bool

+ type CelerLedgerIntendWithdraw struct

+ Amount *big.Int

+ ChannelId [32]byte

+ Raw types.Log

+ Receiver common.Address

+ type CelerLedgerIntendWithdrawIterator struct

+ Event *CelerLedgerIntendWithdraw

+ func (it *CelerLedgerIntendWithdrawIterator) Close() error

+ func (it *CelerLedgerIntendWithdrawIterator) Error() error

+ func (it *CelerLedgerIntendWithdrawIterator) Next() bool

+ type CelerLedgerMigrateChannelFrom struct

+ ChannelId [32]byte

+ OldLedgerAddr common.Address

+ Raw types.Log

+ type CelerLedgerMigrateChannelFromIterator struct

+ Event *CelerLedgerMigrateChannelFrom

+ func (it *CelerLedgerMigrateChannelFromIterator) Close() error

+ func (it *CelerLedgerMigrateChannelFromIterator) Error() error

+ func (it *CelerLedgerMigrateChannelFromIterator) Next() bool

+ type CelerLedgerMigrateChannelTo struct

+ ChannelId [32]byte

+ NewLedgerAddr common.Address

+ Raw types.Log

+ type CelerLedgerMigrateChannelToIterator struct

+ Event *CelerLedgerMigrateChannelTo

+ func (it *CelerLedgerMigrateChannelToIterator) Close() error

+ func (it *CelerLedgerMigrateChannelToIterator) Error() error

+ func (it *CelerLedgerMigrateChannelToIterator) Next() bool

+ type CelerLedgerOpenChannel struct

+ ChannelId [32]byte

+ InitialDeposits [2]*big.Int

+ PeerAddrs [2]common.Address

+ Raw types.Log

+ TokenAddress common.Address

+ TokenType *big.Int

+ type CelerLedgerOpenChannelIterator struct

+ Event *CelerLedgerOpenChannel

+ func (it *CelerLedgerOpenChannelIterator) Close() error

+ func (it *CelerLedgerOpenChannelIterator) Error() error

+ func (it *CelerLedgerOpenChannelIterator) Next() bool

+ type CelerLedgerOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type CelerLedgerOwnershipTransferredIterator struct

+ Event *CelerLedgerOwnershipTransferred

+ func (it *CelerLedgerOwnershipTransferredIterator) Close() error

+ func (it *CelerLedgerOwnershipTransferredIterator) Error() error

+ func (it *CelerLedgerOwnershipTransferredIterator) Next() bool

+ type CelerLedgerRaw struct

+ Contract *CelerLedger

+ func (_CelerLedger *CelerLedgerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_CelerLedger *CelerLedgerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type CelerLedgerSession struct

+ CallOpts bind.CallOpts

+ Contract *CelerLedger

+ TransactOpts bind.TransactOpts

+ func (_CelerLedger *CelerLedgerSession) ClearPays(_channelId [32]byte, _peerFrom common.Address, _payIdList []byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerSession) ConfirmSettle(_channelId [32]byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerSession) ConfirmWithdraw(_channelId [32]byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerSession) CooperativeSettle(_settleRequest []byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerSession) CooperativeWithdraw(_cooperativeWithdrawRequest []byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerSession) Deposit(_channelId [32]byte, _receiver common.Address, _transferFromAmount *big.Int) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerSession) DepositInBatch(_channelIds [][32]byte, _receivers []common.Address, ...) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerSession) DisableBalanceLimits() (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerSession) EnableBalanceLimits() (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerSession) GetBalanceLimit(_tokenAddr common.Address) (*big.Int, error)

+ func (_CelerLedger *CelerLedgerSession) GetBalanceLimitsEnabled() (bool, error)

+ func (_CelerLedger *CelerLedgerSession) GetBalanceMap(_channelId [32]byte) ([2]common.Address, [2]*big.Int, [2]*big.Int, error)

+ func (_CelerLedger *CelerLedgerSession) GetCelerWallet() (common.Address, error)

+ func (_CelerLedger *CelerLedgerSession) GetChannelMigrationArgs(_channelId [32]byte) (*big.Int, *big.Int, common.Address, *big.Int, error)

+ func (_CelerLedger *CelerLedgerSession) GetChannelStatus(_channelId [32]byte) (uint8, error)

+ func (_CelerLedger *CelerLedgerSession) GetChannelStatusNum(_channelStatus *big.Int) (*big.Int, error)

+ func (_CelerLedger *CelerLedgerSession) GetCooperativeWithdrawSeqNum(_channelId [32]byte) (*big.Int, error)

+ func (_CelerLedger *CelerLedgerSession) GetDisputeTimeout(_channelId [32]byte) (*big.Int, error)

+ func (_CelerLedger *CelerLedgerSession) GetEthPool() (common.Address, error)

+ func (_CelerLedger *CelerLedgerSession) GetLastPayResolveDeadlineMap(_channelId [32]byte) ([2]common.Address, [2]*big.Int, error)

+ func (_CelerLedger *CelerLedgerSession) GetMigratedTo(_channelId [32]byte) (common.Address, error)

+ func (_CelerLedger *CelerLedgerSession) GetNextPayIdListHashMap(_channelId [32]byte) ([2]common.Address, [2][32]byte, error)

+ func (_CelerLedger *CelerLedgerSession) GetPayRegistry() (common.Address, error)

+ func (_CelerLedger *CelerLedgerSession) GetPeersMigrationInfo(_channelId [32]byte) ([2]common.Address, [2]*big.Int, [2]*big.Int, [2]*big.Int, [2]*big.Int, ...)

+ func (_CelerLedger *CelerLedgerSession) GetPendingPayOutMap(_channelId [32]byte) ([2]common.Address, [2]*big.Int, error)

+ func (_CelerLedger *CelerLedgerSession) GetSettleFinalizedTime(_channelId [32]byte) (*big.Int, error)

+ func (_CelerLedger *CelerLedgerSession) GetStateSeqNumMap(_channelId [32]byte) ([2]common.Address, [2]*big.Int, error)

+ func (_CelerLedger *CelerLedgerSession) GetTokenContract(_channelId [32]byte) (common.Address, error)

+ func (_CelerLedger *CelerLedgerSession) GetTokenType(_channelId [32]byte) (uint8, error)

+ func (_CelerLedger *CelerLedgerSession) GetTotalBalance(_channelId [32]byte) (*big.Int, error)

+ func (_CelerLedger *CelerLedgerSession) GetTransferOutMap(_channelId [32]byte) ([2]common.Address, [2]*big.Int, error)

+ func (_CelerLedger *CelerLedgerSession) GetWithdrawIntent(_channelId [32]byte) (common.Address, *big.Int, *big.Int, [32]byte, error)

+ func (_CelerLedger *CelerLedgerSession) IntendSettle(_signedSimplexStateArray []byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerSession) IntendWithdraw(_channelId [32]byte, _amount *big.Int, _recipientChannelId [32]byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerSession) IsOwner() (bool, error)

+ func (_CelerLedger *CelerLedgerSession) MigrateChannelFrom(_fromLedgerAddr common.Address, _migrationRequest []byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerSession) MigrateChannelTo(_migrationRequest []byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerSession) OpenChannel(_openRequest []byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerSession) Owner() (common.Address, error)

+ func (_CelerLedger *CelerLedgerSession) RenounceOwnership() (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerSession) SetBalanceLimits(_tokenAddrs []common.Address, _limits []*big.Int) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerSession) SnapshotStates(_signedSimplexStateArray []byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerSession) VetoWithdraw(_channelId [32]byte) (*types.Transaction, error)

+ type CelerLedgerSnapshotStates struct

+ ChannelId [32]byte

+ Raw types.Log

+ SeqNums [2]*big.Int

+ type CelerLedgerSnapshotStatesIterator struct

+ Event *CelerLedgerSnapshotStates

+ func (it *CelerLedgerSnapshotStatesIterator) Close() error

+ func (it *CelerLedgerSnapshotStatesIterator) Error() error

+ func (it *CelerLedgerSnapshotStatesIterator) Next() bool

+ type CelerLedgerTransactor struct

+ func NewCelerLedgerTransactor(address common.Address, transactor bind.ContractTransactor) (*CelerLedgerTransactor, error)

+ func (_CelerLedger *CelerLedgerTransactor) ClearPays(opts *bind.TransactOpts, _channelId [32]byte, _peerFrom common.Address, ...) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactor) ConfirmSettle(opts *bind.TransactOpts, _channelId [32]byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactor) ConfirmWithdraw(opts *bind.TransactOpts, _channelId [32]byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactor) CooperativeSettle(opts *bind.TransactOpts, _settleRequest []byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactor) CooperativeWithdraw(opts *bind.TransactOpts, _cooperativeWithdrawRequest []byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactor) Deposit(opts *bind.TransactOpts, _channelId [32]byte, _receiver common.Address, ...) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactor) DepositInBatch(opts *bind.TransactOpts, _channelIds [][32]byte, _receivers []common.Address, ...) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactor) DisableBalanceLimits(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactor) EnableBalanceLimits(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactor) IntendSettle(opts *bind.TransactOpts, _signedSimplexStateArray []byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactor) IntendWithdraw(opts *bind.TransactOpts, _channelId [32]byte, _amount *big.Int, ...) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactor) MigrateChannelFrom(opts *bind.TransactOpts, _fromLedgerAddr common.Address, ...) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactor) MigrateChannelTo(opts *bind.TransactOpts, _migrationRequest []byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactor) OpenChannel(opts *bind.TransactOpts, _openRequest []byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactor) SetBalanceLimits(opts *bind.TransactOpts, _tokenAddrs []common.Address, _limits []*big.Int) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactor) SnapshotStates(opts *bind.TransactOpts, _signedSimplexStateArray []byte) (*types.Transaction, error)

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

+ func (_CelerLedger *CelerLedgerTransactor) VetoWithdraw(opts *bind.TransactOpts, _channelId [32]byte) (*types.Transaction, error)

+ type CelerLedgerTransactorRaw struct

+ Contract *CelerLedgerTransactor

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

+ func (_CelerLedger *CelerLedgerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type CelerLedgerTransactorSession struct

+ Contract *CelerLedgerTransactor

+ TransactOpts bind.TransactOpts

+ func (_CelerLedger *CelerLedgerTransactorSession) ClearPays(_channelId [32]byte, _peerFrom common.Address, _payIdList []byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactorSession) ConfirmSettle(_channelId [32]byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactorSession) ConfirmWithdraw(_channelId [32]byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactorSession) CooperativeSettle(_settleRequest []byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactorSession) CooperativeWithdraw(_cooperativeWithdrawRequest []byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactorSession) Deposit(_channelId [32]byte, _receiver common.Address, _transferFromAmount *big.Int) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactorSession) DepositInBatch(_channelIds [][32]byte, _receivers []common.Address, ...) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactorSession) DisableBalanceLimits() (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactorSession) EnableBalanceLimits() (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactorSession) IntendSettle(_signedSimplexStateArray []byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactorSession) IntendWithdraw(_channelId [32]byte, _amount *big.Int, _recipientChannelId [32]byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactorSession) MigrateChannelFrom(_fromLedgerAddr common.Address, _migrationRequest []byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactorSession) MigrateChannelTo(_migrationRequest []byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactorSession) OpenChannel(_openRequest []byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactorSession) SetBalanceLimits(_tokenAddrs []common.Address, _limits []*big.Int) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactorSession) SnapshotStates(_signedSimplexStateArray []byte) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_CelerLedger *CelerLedgerTransactorSession) VetoWithdraw(_channelId [32]byte) (*types.Transaction, error)

+ type CelerLedgerVetoWithdraw struct

+ ChannelId [32]byte

+ Raw types.Log

+ type CelerLedgerVetoWithdrawIterator struct

+ Event *CelerLedgerVetoWithdraw

+ func (it *CelerLedgerVetoWithdrawIterator) Close() error

+ func (it *CelerLedgerVetoWithdrawIterator) Error() error

+ func (it *CelerLedgerVetoWithdrawIterator) Next() bool

+ type CidType = ec.Hash

+ func Bytes2Cid(b []byte) CidType

+ func Hex2Cid(s string) CidType

+ type ERC20 struct

+ func DeployERC20(auth *bind.TransactOpts, backend bind.ContractBackend, _initialAmount *big.Int, ...) (common.Address, *types.Transaction, *ERC20, error)

+ func NewERC20(address common.Address, backend bind.ContractBackend) (*ERC20, error)

+ type ERC20Approval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type ERC20ApprovalIterator struct

+ Event *ERC20Approval

+ func (it *ERC20ApprovalIterator) Close() error

+ func (it *ERC20ApprovalIterator) Error() error

+ func (it *ERC20ApprovalIterator) Next() bool

+ type ERC20Caller struct

+ func NewERC20Caller(address common.Address, caller bind.ContractCaller) (*ERC20Caller, error)

+ func (_ERC20 *ERC20Caller) Allowance(opts *bind.CallOpts, _owner common.Address, _spender common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20Caller) Allowed(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20Caller) BalanceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20Caller) Balances(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20Caller) Decimals(opts *bind.CallOpts) (uint8, error)

+ func (_ERC20 *ERC20Caller) Name(opts *bind.CallOpts) (string, error)

+ func (_ERC20 *ERC20Caller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_ERC20 *ERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type ERC20CallerRaw struct

+ Contract *ERC20Caller

+ func (_ERC20 *ERC20CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ERC20CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC20Caller

+ func (_ERC20 *ERC20CallerSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20CallerSession) Allowed(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20CallerSession) BalanceOf(_owner common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20CallerSession) Balances(arg0 common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20CallerSession) Decimals() (uint8, error)

+ func (_ERC20 *ERC20CallerSession) Name() (string, error)

+ func (_ERC20 *ERC20CallerSession) Symbol() (string, error)

+ func (_ERC20 *ERC20CallerSession) TotalSupply() (*big.Int, error)

+ type ERC20Filterer struct

+ func NewERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*ERC20Filterer, error)

+ func (_ERC20 *ERC20Filterer) FilterApproval(opts *bind.FilterOpts, _owner []common.Address, _spender []common.Address) (*ERC20ApprovalIterator, error)

+ func (_ERC20 *ERC20Filterer) FilterTransfer(opts *bind.FilterOpts, _from []common.Address, _to []common.Address) (*ERC20TransferIterator, error)

+ func (_ERC20 *ERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20Approval, _owner []common.Address, ...) (event.Subscription, error)

+ func (_ERC20 *ERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20Transfer, _from []common.Address, ...) (event.Subscription, error)

+ type ERC20Interface struct

+ func DeployERC20Interface(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC20Interface, error)

+ func NewERC20Interface(address common.Address, backend bind.ContractBackend) (*ERC20Interface, error)

+ type ERC20InterfaceApproval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type ERC20InterfaceApprovalIterator struct

+ Event *ERC20InterfaceApproval

+ func (it *ERC20InterfaceApprovalIterator) Close() error

+ func (it *ERC20InterfaceApprovalIterator) Error() error

+ func (it *ERC20InterfaceApprovalIterator) Next() bool

+ type ERC20InterfaceCaller struct

+ func NewERC20InterfaceCaller(address common.Address, caller bind.ContractCaller) (*ERC20InterfaceCaller, error)

+ func (_ERC20Interface *ERC20InterfaceCaller) Allowance(opts *bind.CallOpts, _owner common.Address, _spender common.Address) (*big.Int, error)

+ func (_ERC20Interface *ERC20InterfaceCaller) BalanceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error)

+ func (_ERC20Interface *ERC20InterfaceCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type ERC20InterfaceCallerRaw struct

+ Contract *ERC20InterfaceCaller

+ func (_ERC20Interface *ERC20InterfaceCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type ERC20InterfaceCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC20InterfaceCaller

+ func (_ERC20Interface *ERC20InterfaceCallerSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error)

+ func (_ERC20Interface *ERC20InterfaceCallerSession) BalanceOf(_owner common.Address) (*big.Int, error)

+ func (_ERC20Interface *ERC20InterfaceCallerSession) TotalSupply() (*big.Int, error)

+ type ERC20InterfaceFilterer struct

+ func NewERC20InterfaceFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20InterfaceFilterer, error)

+ func (_ERC20Interface *ERC20InterfaceFilterer) FilterApproval(opts *bind.FilterOpts, _owner []common.Address, _spender []common.Address) (*ERC20InterfaceApprovalIterator, error)

+ func (_ERC20Interface *ERC20InterfaceFilterer) FilterTransfer(opts *bind.FilterOpts, _from []common.Address, _to []common.Address) (*ERC20InterfaceTransferIterator, error)

+ func (_ERC20Interface *ERC20InterfaceFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20InterfaceApproval, ...) (event.Subscription, error)

+ func (_ERC20Interface *ERC20InterfaceFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20InterfaceTransfer, ...) (event.Subscription, error)

+ type ERC20InterfaceRaw struct

+ Contract *ERC20Interface

+ func (_ERC20Interface *ERC20InterfaceRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_ERC20Interface *ERC20InterfaceRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC20InterfaceSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC20Interface

+ TransactOpts bind.TransactOpts

+ func (_ERC20Interface *ERC20InterfaceSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error)

+ func (_ERC20Interface *ERC20InterfaceSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_ERC20Interface *ERC20InterfaceSession) BalanceOf(_owner common.Address) (*big.Int, error)

+ func (_ERC20Interface *ERC20InterfaceSession) TotalSupply() (*big.Int, error)

+ func (_ERC20Interface *ERC20InterfaceSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_ERC20Interface *ERC20InterfaceSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error)

+ type ERC20InterfaceTransactor struct

+ func NewERC20InterfaceTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20InterfaceTransactor, error)

+ func (_ERC20Interface *ERC20InterfaceTransactor) Approve(opts *bind.TransactOpts, _spender common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_ERC20Interface *ERC20InterfaceTransactor) Transfer(opts *bind.TransactOpts, _to common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_ERC20Interface *ERC20InterfaceTransactor) TransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ type ERC20InterfaceTransactorRaw struct

+ Contract *ERC20InterfaceTransactor

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

+ func (_ERC20Interface *ERC20InterfaceTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC20InterfaceTransactorSession struct

+ Contract *ERC20InterfaceTransactor

+ TransactOpts bind.TransactOpts

+ func (_ERC20Interface *ERC20InterfaceTransactorSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_ERC20Interface *ERC20InterfaceTransactorSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_ERC20Interface *ERC20InterfaceTransactorSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error)

+ type ERC20InterfaceTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type ERC20InterfaceTransferIterator struct

+ Event *ERC20InterfaceTransfer

+ func (it *ERC20InterfaceTransferIterator) Close() error

+ func (it *ERC20InterfaceTransferIterator) Error() error

+ func (it *ERC20InterfaceTransferIterator) Next() bool

+ type ERC20Raw struct

+ Contract *ERC20

+ func (_ERC20 *ERC20Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_ERC20 *ERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC20Session struct

+ CallOpts bind.CallOpts

+ Contract *ERC20

+ TransactOpts bind.TransactOpts

+ func (_ERC20 *ERC20Session) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20Session) Allowed(arg0 common.Address, arg1 common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20Session) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Session) BalanceOf(_owner common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20Session) Balances(arg0 common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20Session) Decimals() (uint8, error)

+ func (_ERC20 *ERC20Session) Name() (string, error)

+ func (_ERC20 *ERC20Session) Symbol() (string, error)

+ func (_ERC20 *ERC20Session) TotalSupply() (*big.Int, error)

+ func (_ERC20 *ERC20Session) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Session) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error)

+ type ERC20Transactor struct

+ func NewERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*ERC20Transactor, error)

+ func (_ERC20 *ERC20Transactor) Approve(opts *bind.TransactOpts, _spender common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Transactor) Transfer(opts *bind.TransactOpts, _to common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Transactor) TransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, ...) (*types.Transaction, error)

+ type ERC20TransactorRaw struct

+ Contract *ERC20Transactor

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

+ func (_ERC20 *ERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC20TransactorSession struct

+ Contract *ERC20Transactor

+ TransactOpts bind.TransactOpts

+ func (_ERC20 *ERC20TransactorSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20TransactorSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20TransactorSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error)

+ type ERC20Transfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type ERC20TransferIterator struct

+ Event *ERC20Transfer

+ func (it *ERC20TransferIterator) Close() error

+ func (it *ERC20TransferIterator) Error() error

+ func (it *ERC20TransferIterator) Next() bool

+ type EthClient struct

+ Address Addr

+ Auth *bind.TransactOpts

+ Client *ethclient.Client

+ Guard *Guard

+ GuardAddress Addr

+ Ledger *CelerLedger

+ LedgerAddress Addr

+ PrivateKey *ecdsa.PrivateKey

+ func NewEthClient(ws, guardAddrStr, ledgerAddrStr, ks, passphrase string) (*EthClient, error)

+ func (ethClient *EthClient) SetAuth(ks, passphrase string) error

+ func (ethClient *EthClient) SetClient(ws string) error

+ func (ethClient *EthClient) SetContracts(guardAddrStr, ledgerAddrStr string) error

+ func (ethClient *EthClient) SignMessage(data []byte) ([]byte, error)

+ type Guard struct

+ func DeployGuard(auth *bind.TransactOpts, backend bind.ContractBackend, ...) (common.Address, *types.Transaction, *Guard, error)

+ func NewGuard(address common.Address, backend bind.ContractBackend) (*Guard, error)

+ type GuardAddSubscriptionBalance struct

+ Amount *big.Int

+ Consumer common.Address

+ Raw types.Log

+ type GuardAddSubscriptionBalanceIterator struct

+ Event *GuardAddSubscriptionBalance

+ func (it *GuardAddSubscriptionBalanceIterator) Close() error

+ func (it *GuardAddSubscriptionBalanceIterator) Error() error

+ func (it *GuardAddSubscriptionBalanceIterator) Next() bool

+ type GuardCaller struct

+ func NewGuardCaller(address common.Address, caller bind.ContractCaller) (*GuardCaller, error)

+ func (_Guard *GuardCaller) BlameTimeout(opts *bind.CallOpts) (*big.Int, error)

+ func (_Guard *GuardCaller) CelerToken(opts *bind.CallOpts) (common.Address, error)

+ func (_Guard *GuardCaller) GetCandidateInfo(opts *bind.CallOpts, _candidateAddr common.Address) (struct{ ... }, error)

+ func (_Guard *GuardCaller) GetDelegatorInfo(opts *bind.CallOpts, _candidateAddr common.Address, ...) (struct{ ... }, error)

+ func (_Guard *GuardCaller) GetMinQuorumStakingPool(opts *bind.CallOpts) (*big.Int, error)

+ func (_Guard *GuardCaller) GetMinStakingPool(opts *bind.CallOpts) (*big.Int, error)

+ func (_Guard *GuardCaller) GetValidatorNum(opts *bind.CallOpts) (*big.Int, error)

+ func (_Guard *GuardCaller) IsValidator(opts *bind.CallOpts, _addr common.Address) (bool, error)

+ func (_Guard *GuardCaller) MaxValidatorNum(opts *bind.CallOpts) (*big.Int, error)

+ func (_Guard *GuardCaller) MinStakeInPool(opts *bind.CallOpts) (*big.Int, error)

+ func (_Guard *GuardCaller) MinValidatorNum(opts *bind.CallOpts) (*big.Int, error)

+ func (_Guard *GuardCaller) MiningPool(opts *bind.CallOpts) (*big.Int, error)

+ func (_Guard *GuardCaller) RedeemedMiningReward(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_Guard *GuardCaller) RedeemedServiceReward(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_Guard *GuardCaller) ServicePool(opts *bind.CallOpts) (*big.Int, error)

+ func (_Guard *GuardCaller) SidechainGoLiveTime(opts *bind.CallOpts) (*big.Int, error)

+ func (_Guard *GuardCaller) SubscriptionDeposits(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error)

+ func (_Guard *GuardCaller) UsedPenaltyNonce(opts *bind.CallOpts, arg0 *big.Int) (bool, error)

+ func (_Guard *GuardCaller) ValidatorSet(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error)

+ type GuardCallerRaw struct

+ Contract *GuardCaller

+ func (_Guard *GuardCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

+ type GuardCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *GuardCaller

+ func (_Guard *GuardCallerSession) BlameTimeout() (*big.Int, error)

+ func (_Guard *GuardCallerSession) CelerToken() (common.Address, error)

+ func (_Guard *GuardCallerSession) GetCandidateInfo(_candidateAddr common.Address) (struct{ ... }, error)

+ func (_Guard *GuardCallerSession) GetDelegatorInfo(_candidateAddr common.Address, _delegatorAddr common.Address) (struct{ ... }, error)

+ func (_Guard *GuardCallerSession) GetMinQuorumStakingPool() (*big.Int, error)

+ func (_Guard *GuardCallerSession) GetMinStakingPool() (*big.Int, error)

+ func (_Guard *GuardCallerSession) GetValidatorNum() (*big.Int, error)

+ func (_Guard *GuardCallerSession) IsValidator(_addr common.Address) (bool, error)

+ func (_Guard *GuardCallerSession) MaxValidatorNum() (*big.Int, error)

+ func (_Guard *GuardCallerSession) MinStakeInPool() (*big.Int, error)

+ func (_Guard *GuardCallerSession) MinValidatorNum() (*big.Int, error)

+ func (_Guard *GuardCallerSession) MiningPool() (*big.Int, error)

+ func (_Guard *GuardCallerSession) RedeemedMiningReward(arg0 common.Address) (*big.Int, error)

+ func (_Guard *GuardCallerSession) RedeemedServiceReward(arg0 common.Address) (*big.Int, error)

+ func (_Guard *GuardCallerSession) ServicePool() (*big.Int, error)

+ func (_Guard *GuardCallerSession) SidechainGoLiveTime() (*big.Int, error)

+ func (_Guard *GuardCallerSession) SubscriptionDeposits(arg0 common.Address) (*big.Int, error)

+ func (_Guard *GuardCallerSession) UsedPenaltyNonce(arg0 *big.Int) (bool, error)

+ func (_Guard *GuardCallerSession) ValidatorSet(arg0 *big.Int) (common.Address, error)

+ type GuardCandidateUnbonded struct

+ Candidate common.Address

+ Raw types.Log

+ type GuardCandidateUnbondedIterator struct

+ Event *GuardCandidateUnbonded

+ func (it *GuardCandidateUnbondedIterator) Close() error

+ func (it *GuardCandidateUnbondedIterator) Error() error

+ func (it *GuardCandidateUnbondedIterator) Next() bool

+ type GuardConfirmWithdraw struct

+ Amount *big.Int

+ Candidate common.Address

+ Delegator common.Address

+ Raw types.Log

+ type GuardConfirmWithdrawIterator struct

+ Event *GuardConfirmWithdraw

+ func (it *GuardConfirmWithdrawIterator) Close() error

+ func (it *GuardConfirmWithdrawIterator) Error() error

+ func (it *GuardConfirmWithdrawIterator) Next() bool

+ type GuardDelegate struct

+ Candidate common.Address

+ Delegator common.Address

+ NewStake *big.Int

+ Raw types.Log

+ StakingPool *big.Int

+ type GuardDelegateIterator struct

+ Event *GuardDelegate

+ func (it *GuardDelegateIterator) Close() error

+ func (it *GuardDelegateIterator) Error() error

+ func (it *GuardDelegateIterator) Next() bool

+ type GuardFilterer struct

+ func NewGuardFilterer(address common.Address, filterer bind.ContractFilterer) (*GuardFilterer, error)

+ func (_Guard *GuardFilterer) FilterAddSubscriptionBalance(opts *bind.FilterOpts, consumer []common.Address) (*GuardAddSubscriptionBalanceIterator, error)

+ func (_Guard *GuardFilterer) FilterCandidateUnbonded(opts *bind.FilterOpts, candidate []common.Address) (*GuardCandidateUnbondedIterator, error)

+ func (_Guard *GuardFilterer) FilterConfirmWithdraw(opts *bind.FilterOpts, delegator []common.Address, candidate []common.Address) (*GuardConfirmWithdrawIterator, error)

+ func (_Guard *GuardFilterer) FilterDelegate(opts *bind.FilterOpts, delegator []common.Address, candidate []common.Address) (*GuardDelegateIterator, error)

+ func (_Guard *GuardFilterer) FilterIndemnify(opts *bind.FilterOpts, indemnitee []common.Address) (*GuardIndemnifyIterator, error)

+ func (_Guard *GuardFilterer) FilterInitializeCandidate(opts *bind.FilterOpts, candidate []common.Address) (*GuardInitializeCandidateIterator, error)

+ func (_Guard *GuardFilterer) FilterIntendWithdraw(opts *bind.FilterOpts, delegator []common.Address, candidate []common.Address) (*GuardIntendWithdrawIterator, error)

+ func (_Guard *GuardFilterer) FilterMiningPoolContribution(opts *bind.FilterOpts, contributor []common.Address) (*GuardMiningPoolContributionIterator, error)

+ func (_Guard *GuardFilterer) FilterPunish(opts *bind.FilterOpts, validator []common.Address, delegator []common.Address) (*GuardPunishIterator, error)

+ func (_Guard *GuardFilterer) FilterRedeemReward(opts *bind.FilterOpts, receiver []common.Address) (*GuardRedeemRewardIterator, error)

+ func (_Guard *GuardFilterer) FilterUpdateSidechainAddr(opts *bind.FilterOpts, candidate []common.Address, oldSidechainAddr [][]byte, ...) (*GuardUpdateSidechainAddrIterator, error)

+ func (_Guard *GuardFilterer) FilterValidatorChange(opts *bind.FilterOpts, ethAddr []common.Address, changeType []uint8) (*GuardValidatorChangeIterator, error)

+ func (_Guard *GuardFilterer) FilterWithdrawFromUnbondedCandidate(opts *bind.FilterOpts, delegator []common.Address, candidate []common.Address) (*GuardWithdrawFromUnbondedCandidateIterator, error)

+ func (_Guard *GuardFilterer) ParseAddSubscriptionBalance(log types.Log) (*GuardAddSubscriptionBalance, error)

+ func (_Guard *GuardFilterer) ParseCandidateUnbonded(log types.Log) (*GuardCandidateUnbonded, error)

+ func (_Guard *GuardFilterer) ParseConfirmWithdraw(log types.Log) (*GuardConfirmWithdraw, error)

+ func (_Guard *GuardFilterer) ParseDelegate(log types.Log) (*GuardDelegate, error)

+ func (_Guard *GuardFilterer) ParseIndemnify(log types.Log) (*GuardIndemnify, error)

+ func (_Guard *GuardFilterer) ParseInitializeCandidate(log types.Log) (*GuardInitializeCandidate, error)

+ func (_Guard *GuardFilterer) ParseIntendWithdraw(log types.Log) (*GuardIntendWithdraw, error)

+ func (_Guard *GuardFilterer) ParseMiningPoolContribution(log types.Log) (*GuardMiningPoolContribution, error)

+ func (_Guard *GuardFilterer) ParsePunish(log types.Log) (*GuardPunish, error)

+ func (_Guard *GuardFilterer) ParseRedeemReward(log types.Log) (*GuardRedeemReward, error)

+ func (_Guard *GuardFilterer) ParseUpdateSidechainAddr(log types.Log) (*GuardUpdateSidechainAddr, error)

+ func (_Guard *GuardFilterer) ParseValidatorChange(log types.Log) (*GuardValidatorChange, error)

+ func (_Guard *GuardFilterer) ParseWithdrawFromUnbondedCandidate(log types.Log) (*GuardWithdrawFromUnbondedCandidate, error)

+ func (_Guard *GuardFilterer) WatchAddSubscriptionBalance(opts *bind.WatchOpts, sink chan<- *GuardAddSubscriptionBalance, ...) (event.Subscription, error)

+ func (_Guard *GuardFilterer) WatchCandidateUnbonded(opts *bind.WatchOpts, sink chan<- *GuardCandidateUnbonded, ...) (event.Subscription, error)

+ func (_Guard *GuardFilterer) WatchConfirmWithdraw(opts *bind.WatchOpts, sink chan<- *GuardConfirmWithdraw, ...) (event.Subscription, error)

+ func (_Guard *GuardFilterer) WatchDelegate(opts *bind.WatchOpts, sink chan<- *GuardDelegate, delegator []common.Address, ...) (event.Subscription, error)

+ func (_Guard *GuardFilterer) WatchIndemnify(opts *bind.WatchOpts, sink chan<- *GuardIndemnify, indemnitee []common.Address) (event.Subscription, error)

+ func (_Guard *GuardFilterer) WatchInitializeCandidate(opts *bind.WatchOpts, sink chan<- *GuardInitializeCandidate, ...) (event.Subscription, error)

+ func (_Guard *GuardFilterer) WatchIntendWithdraw(opts *bind.WatchOpts, sink chan<- *GuardIntendWithdraw, ...) (event.Subscription, error)

+ func (_Guard *GuardFilterer) WatchMiningPoolContribution(opts *bind.WatchOpts, sink chan<- *GuardMiningPoolContribution, ...) (event.Subscription, error)

+ func (_Guard *GuardFilterer) WatchPunish(opts *bind.WatchOpts, sink chan<- *GuardPunish, validator []common.Address, ...) (event.Subscription, error)

+ func (_Guard *GuardFilterer) WatchRedeemReward(opts *bind.WatchOpts, sink chan<- *GuardRedeemReward, ...) (event.Subscription, error)

+ func (_Guard *GuardFilterer) WatchUpdateSidechainAddr(opts *bind.WatchOpts, sink chan<- *GuardUpdateSidechainAddr, ...) (event.Subscription, error)

+ func (_Guard *GuardFilterer) WatchValidatorChange(opts *bind.WatchOpts, sink chan<- *GuardValidatorChange, ...) (event.Subscription, error)

+ func (_Guard *GuardFilterer) WatchWithdrawFromUnbondedCandidate(opts *bind.WatchOpts, sink chan<- *GuardWithdrawFromUnbondedCandidate, ...) (event.Subscription, error)

+ type GuardIndemnify struct

+ Amount *big.Int

+ Indemnitee common.Address

+ Raw types.Log

+ type GuardIndemnifyIterator struct

+ Event *GuardIndemnify

+ func (it *GuardIndemnifyIterator) Close() error

+ func (it *GuardIndemnifyIterator) Error() error

+ func (it *GuardIndemnifyIterator) Next() bool

+ type GuardInitializeCandidate struct

+ Candidate common.Address

+ MinSelfStake *big.Int

+ Raw types.Log

+ SidechainAddr []byte

+ type GuardInitializeCandidateIterator struct

+ Event *GuardInitializeCandidate

+ func (it *GuardInitializeCandidateIterator) Close() error

+ func (it *GuardInitializeCandidateIterator) Error() error

+ func (it *GuardInitializeCandidateIterator) Next() bool

+ type GuardIntendWithdraw struct

+ Candidate common.Address

+ Delegator common.Address

+ ProposedTime *big.Int

+ Raw types.Log

+ WithdrawAmount *big.Int

+ type GuardIntendWithdrawIterator struct

+ Event *GuardIntendWithdraw

+ func (it *GuardIntendWithdrawIterator) Close() error

+ func (it *GuardIntendWithdrawIterator) Error() error

+ func (it *GuardIntendWithdrawIterator) Next() bool

+ type GuardMiningPoolContribution struct

+ Contribution *big.Int

+ Contributor common.Address

+ MiningPoolSize *big.Int

+ Raw types.Log

+ type GuardMiningPoolContributionIterator struct

+ Event *GuardMiningPoolContribution

+ func (it *GuardMiningPoolContributionIterator) Close() error

+ func (it *GuardMiningPoolContributionIterator) Error() error

+ func (it *GuardMiningPoolContributionIterator) Next() bool

+ type GuardPunish struct

+ Amount *big.Int

+ Delegator common.Address

+ Raw types.Log

+ Validator common.Address

+ type GuardPunishIterator struct

+ Event *GuardPunish

+ func (it *GuardPunishIterator) Close() error

+ func (it *GuardPunishIterator) Error() error

+ func (it *GuardPunishIterator) Next() bool

+ type GuardRaw struct

+ Contract *Guard

+ func (_Guard *GuardRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

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

+ func (_Guard *GuardRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type GuardRedeemReward struct

+ MiningPool *big.Int

+ MiningReward *big.Int

+ Raw types.Log

+ Receiver common.Address

+ ServicePool *big.Int

+ ServiceReward *big.Int

+ type GuardRedeemRewardIterator struct

+ Event *GuardRedeemReward

+ func (it *GuardRedeemRewardIterator) Close() error

+ func (it *GuardRedeemRewardIterator) Error() error

+ func (it *GuardRedeemRewardIterator) Next() bool

+ type GuardSession struct

+ CallOpts bind.CallOpts

+ Contract *Guard

+ TransactOpts bind.TransactOpts

+ func (_Guard *GuardSession) BlameTimeout() (*big.Int, error)

+ func (_Guard *GuardSession) CelerToken() (common.Address, error)

+ func (_Guard *GuardSession) ClaimValidator() (*types.Transaction, error)

+ func (_Guard *GuardSession) ConfirmUnbondedCandidate(_candidateAddr common.Address) (*types.Transaction, error)

+ func (_Guard *GuardSession) ConfirmWithdraw(_candidateAddr common.Address) (*types.Transaction, error)

+ func (_Guard *GuardSession) ContributeToMiningPool(_amount *big.Int) (*types.Transaction, error)

+ func (_Guard *GuardSession) Delegate(_candidateAddr common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Guard *GuardSession) GetCandidateInfo(_candidateAddr common.Address) (struct{ ... }, error)

+ func (_Guard *GuardSession) GetDelegatorInfo(_candidateAddr common.Address, _delegatorAddr common.Address) (struct{ ... }, error)

+ func (_Guard *GuardSession) GetMinQuorumStakingPool() (*big.Int, error)

+ func (_Guard *GuardSession) GetMinStakingPool() (*big.Int, error)

+ func (_Guard *GuardSession) GetValidatorNum() (*big.Int, error)

+ func (_Guard *GuardSession) InitializeCandidate(_minSelfStake *big.Int, _sidechainAddr []byte) (*types.Transaction, error)

+ func (_Guard *GuardSession) IntendWithdraw(_candidateAddr common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Guard *GuardSession) IsValidator(_addr common.Address) (bool, error)

+ func (_Guard *GuardSession) MaxValidatorNum() (*big.Int, error)

+ func (_Guard *GuardSession) MinStakeInPool() (*big.Int, error)

+ func (_Guard *GuardSession) MinValidatorNum() (*big.Int, error)

+ func (_Guard *GuardSession) MiningPool() (*big.Int, error)

+ func (_Guard *GuardSession) Punish(_penaltyRequest []byte) (*types.Transaction, error)

+ func (_Guard *GuardSession) RedeemReward(_rewardRequest []byte) (*types.Transaction, error)

+ func (_Guard *GuardSession) RedeemedMiningReward(arg0 common.Address) (*big.Int, error)

+ func (_Guard *GuardSession) RedeemedServiceReward(arg0 common.Address) (*big.Int, error)

+ func (_Guard *GuardSession) ServicePool() (*big.Int, error)

+ func (_Guard *GuardSession) SidechainGoLiveTime() (*big.Int, error)

+ func (_Guard *GuardSession) Subscribe(_amount *big.Int) (*types.Transaction, error)

+ func (_Guard *GuardSession) SubscriptionDeposits(arg0 common.Address) (*big.Int, error)

+ func (_Guard *GuardSession) UpdateSidechainAddr(_sidechainAddr []byte) (*types.Transaction, error)

+ func (_Guard *GuardSession) UsedPenaltyNonce(arg0 *big.Int) (bool, error)

+ func (_Guard *GuardSession) ValidatorSet(arg0 *big.Int) (common.Address, error)

+ func (_Guard *GuardSession) WithdrawFromUnbondedCandidate(_candidateAddr common.Address, _amount *big.Int) (*types.Transaction, error)

+ type GuardTransactor struct

+ func NewGuardTransactor(address common.Address, transactor bind.ContractTransactor) (*GuardTransactor, error)

+ func (_Guard *GuardTransactor) ClaimValidator(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Guard *GuardTransactor) ConfirmUnbondedCandidate(opts *bind.TransactOpts, _candidateAddr common.Address) (*types.Transaction, error)

+ func (_Guard *GuardTransactor) ConfirmWithdraw(opts *bind.TransactOpts, _candidateAddr common.Address) (*types.Transaction, error)

+ func (_Guard *GuardTransactor) ContributeToMiningPool(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error)

+ func (_Guard *GuardTransactor) Delegate(opts *bind.TransactOpts, _candidateAddr common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Guard *GuardTransactor) InitializeCandidate(opts *bind.TransactOpts, _minSelfStake *big.Int, _sidechainAddr []byte) (*types.Transaction, error)

+ func (_Guard *GuardTransactor) IntendWithdraw(opts *bind.TransactOpts, _candidateAddr common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Guard *GuardTransactor) Punish(opts *bind.TransactOpts, _penaltyRequest []byte) (*types.Transaction, error)

+ func (_Guard *GuardTransactor) RedeemReward(opts *bind.TransactOpts, _rewardRequest []byte) (*types.Transaction, error)

+ func (_Guard *GuardTransactor) Subscribe(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error)

+ func (_Guard *GuardTransactor) UpdateSidechainAddr(opts *bind.TransactOpts, _sidechainAddr []byte) (*types.Transaction, error)

+ func (_Guard *GuardTransactor) WithdrawFromUnbondedCandidate(opts *bind.TransactOpts, _candidateAddr common.Address, _amount *big.Int) (*types.Transaction, error)

+ type GuardTransactorRaw struct

+ Contract *GuardTransactor

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

+ func (_Guard *GuardTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type GuardTransactorSession struct

+ Contract *GuardTransactor

+ TransactOpts bind.TransactOpts

+ func (_Guard *GuardTransactorSession) ClaimValidator() (*types.Transaction, error)

+ func (_Guard *GuardTransactorSession) ConfirmUnbondedCandidate(_candidateAddr common.Address) (*types.Transaction, error)

+ func (_Guard *GuardTransactorSession) ConfirmWithdraw(_candidateAddr common.Address) (*types.Transaction, error)

+ func (_Guard *GuardTransactorSession) ContributeToMiningPool(_amount *big.Int) (*types.Transaction, error)

+ func (_Guard *GuardTransactorSession) Delegate(_candidateAddr common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Guard *GuardTransactorSession) InitializeCandidate(_minSelfStake *big.Int, _sidechainAddr []byte) (*types.Transaction, error)

+ func (_Guard *GuardTransactorSession) IntendWithdraw(_candidateAddr common.Address, _amount *big.Int) (*types.Transaction, error)

+ func (_Guard *GuardTransactorSession) Punish(_penaltyRequest []byte) (*types.Transaction, error)

+ func (_Guard *GuardTransactorSession) RedeemReward(_rewardRequest []byte) (*types.Transaction, error)

+ func (_Guard *GuardTransactorSession) Subscribe(_amount *big.Int) (*types.Transaction, error)

+ func (_Guard *GuardTransactorSession) UpdateSidechainAddr(_sidechainAddr []byte) (*types.Transaction, error)

+ func (_Guard *GuardTransactorSession) WithdrawFromUnbondedCandidate(_candidateAddr common.Address, _amount *big.Int) (*types.Transaction, error)

+ type GuardUpdateSidechainAddr struct

+ Candidate common.Address

+ NewSidechainAddr common.Hash

+ OldSidechainAddr common.Hash

+ Raw types.Log

+ type GuardUpdateSidechainAddrIterator struct

+ Event *GuardUpdateSidechainAddr

+ func (it *GuardUpdateSidechainAddrIterator) Close() error

+ func (it *GuardUpdateSidechainAddrIterator) Error() error

+ func (it *GuardUpdateSidechainAddrIterator) Next() bool

+ type GuardValidatorChange struct

+ ChangeType uint8

+ EthAddr common.Address

+ Raw types.Log

+ type GuardValidatorChangeIterator struct

+ Event *GuardValidatorChange

+ func (it *GuardValidatorChangeIterator) Close() error

+ func (it *GuardValidatorChangeIterator) Error() error

+ func (it *GuardValidatorChangeIterator) Next() bool

+ type GuardWithdrawFromUnbondedCandidate struct

+ Amount *big.Int

+ Candidate common.Address

+ Delegator common.Address

+ Raw types.Log

+ type GuardWithdrawFromUnbondedCandidateIterator struct

+ Event *GuardWithdrawFromUnbondedCandidate

+ func (it *GuardWithdrawFromUnbondedCandidateIterator) Close() error

+ func (it *GuardWithdrawFromUnbondedCandidateIterator) Error() error

+ func (it *GuardWithdrawFromUnbondedCandidateIterator) Next() bool

+ type HashType = ec.Hash

+ func Bytes2Hash(b []byte) HashType

+ func GetEventSignature(eventSigStr string) HashType

+ func Hex2Hash(s string) HashType

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