api

package

Go to main page

Versions in this module

v0

v0.4.31

May 15, 2020

v0.4.30

Aug 2, 2019

v0.4.29

Jul 19, 2019

v0.4.28

May 24, 2019

v0.4.27

May 22, 2019

v0.4.26

May 21, 2019

v0.4.25

Apr 30, 2019

v0.4.22

Feb 1, 2019

v0.4.21

Jan 29, 2019

Changes in this version

+ const DevicesStorageABI

+ const DevicesStorageBin

+ type DevicesStorage struct

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

+ func NewDevicesStorage(address common.Address, backend bind.ContractBackend) (*DevicesStorage, error)

+ type DevicesStorageCaller struct

+ func NewDevicesStorageCaller(address common.Address, caller bind.ContractCaller) (*DevicesStorageCaller, error)

+ func (_DevicesStorage *DevicesStorageCaller) GetDevices(opts *bind.CallOpts, _owner common.Address) (struct{ ... }, error)

+ func (_DevicesStorage *DevicesStorageCaller) Hash(opts *bind.CallOpts, _owner common.Address) ([32]byte, error)

+ func (_DevicesStorage *DevicesStorageCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ type DevicesStorageCallerRaw struct

+ Contract *DevicesStorageCaller

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

+ type DevicesStorageCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *DevicesStorageCaller

+ func (_DevicesStorage *DevicesStorageCallerSession) GetDevices(_owner common.Address) (struct{ ... }, error)

+ func (_DevicesStorage *DevicesStorageCallerSession) Hash(_owner common.Address) ([32]byte, error)

+ func (_DevicesStorage *DevicesStorageCallerSession) Owner() (common.Address, error)

+ type DevicesStorageDevicesHasSet struct

+ Owner common.Address

+ Raw types.Log

+ type DevicesStorageDevicesHasSetIterator struct

+ Event *DevicesStorageDevicesHasSet

+ func (it *DevicesStorageDevicesHasSetIterator) Close() error

+ func (it *DevicesStorageDevicesHasSetIterator) Error() error

+ func (it *DevicesStorageDevicesHasSetIterator) Next() bool

+ type DevicesStorageDevicesTimestampUpdated struct

+ Owner common.Address

+ Raw types.Log

+ type DevicesStorageDevicesTimestampUpdatedIterator struct

+ Event *DevicesStorageDevicesTimestampUpdated

+ func (it *DevicesStorageDevicesTimestampUpdatedIterator) Close() error

+ func (it *DevicesStorageDevicesTimestampUpdatedIterator) Error() error

+ func (it *DevicesStorageDevicesTimestampUpdatedIterator) Next() bool

+ type DevicesStorageDevicesUpdated struct

+ Owner common.Address

+ Raw types.Log

+ type DevicesStorageDevicesUpdatedIterator struct

+ Event *DevicesStorageDevicesUpdated

+ func (it *DevicesStorageDevicesUpdatedIterator) Close() error

+ func (it *DevicesStorageDevicesUpdatedIterator) Error() error

+ func (it *DevicesStorageDevicesUpdatedIterator) Next() bool

+ type DevicesStorageFilterer struct

+ func NewDevicesStorageFilterer(address common.Address, filterer bind.ContractFilterer) (*DevicesStorageFilterer, error)

+ func (_DevicesStorage *DevicesStorageFilterer) FilterDevicesHasSet(opts *bind.FilterOpts, owner []common.Address) (*DevicesStorageDevicesHasSetIterator, error)

+ func (_DevicesStorage *DevicesStorageFilterer) FilterDevicesTimestampUpdated(opts *bind.FilterOpts, owner []common.Address) (*DevicesStorageDevicesTimestampUpdatedIterator, error)

+ func (_DevicesStorage *DevicesStorageFilterer) FilterDevicesUpdated(opts *bind.FilterOpts, owner []common.Address) (*DevicesStorageDevicesUpdatedIterator, error)

+ func (_DevicesStorage *DevicesStorageFilterer) FilterOwnershipRenounced(opts *bind.FilterOpts, previousOwner []common.Address) (*DevicesStorageOwnershipRenouncedIterator, error)

+ func (_DevicesStorage *DevicesStorageFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*DevicesStorageOwnershipTransferredIterator, error)

+ func (_DevicesStorage *DevicesStorageFilterer) FilterSuicide(opts *bind.FilterOpts) (*DevicesStorageSuicideIterator, error)

+ func (_DevicesStorage *DevicesStorageFilterer) WatchDevicesHasSet(opts *bind.WatchOpts, sink chan<- *DevicesStorageDevicesHasSet, ...) (event.Subscription, error)

+ func (_DevicesStorage *DevicesStorageFilterer) WatchDevicesTimestampUpdated(opts *bind.WatchOpts, sink chan<- *DevicesStorageDevicesTimestampUpdated, ...) (event.Subscription, error)

+ func (_DevicesStorage *DevicesStorageFilterer) WatchDevicesUpdated(opts *bind.WatchOpts, sink chan<- *DevicesStorageDevicesUpdated, ...) (event.Subscription, error)

+ func (_DevicesStorage *DevicesStorageFilterer) WatchOwnershipRenounced(opts *bind.WatchOpts, sink chan<- *DevicesStorageOwnershipRenounced, ...) (event.Subscription, error)

+ func (_DevicesStorage *DevicesStorageFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *DevicesStorageOwnershipTransferred, ...) (event.Subscription, error)

+ func (_DevicesStorage *DevicesStorageFilterer) WatchSuicide(opts *bind.WatchOpts, sink chan<- *DevicesStorageSuicide) (event.Subscription, error)

+ type DevicesStorageOwnershipRenounced struct

+ PreviousOwner common.Address

+ Raw types.Log

+ type DevicesStorageOwnershipRenouncedIterator struct

+ Event *DevicesStorageOwnershipRenounced

+ func (it *DevicesStorageOwnershipRenouncedIterator) Close() error

+ func (it *DevicesStorageOwnershipRenouncedIterator) Error() error

+ func (it *DevicesStorageOwnershipRenouncedIterator) Next() bool

+ type DevicesStorageOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type DevicesStorageOwnershipTransferredIterator struct

+ Event *DevicesStorageOwnershipTransferred

+ func (it *DevicesStorageOwnershipTransferredIterator) Close() error

+ func (it *DevicesStorageOwnershipTransferredIterator) Error() error

+ func (it *DevicesStorageOwnershipTransferredIterator) Next() bool

+ type DevicesStorageRaw struct

+ Contract *DevicesStorage

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

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

+ func (_DevicesStorage *DevicesStorageRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DevicesStorageSession struct

+ CallOpts bind.CallOpts

+ Contract *DevicesStorage

+ TransactOpts bind.TransactOpts

+ func (_DevicesStorage *DevicesStorageSession) GetDevices(_owner common.Address) (struct{ ... }, error)

+ func (_DevicesStorage *DevicesStorageSession) Hash(_owner common.Address) ([32]byte, error)

+ func (_DevicesStorage *DevicesStorageSession) KillDevicesStorage() (*types.Transaction, error)

+ func (_DevicesStorage *DevicesStorageSession) Owner() (common.Address, error)

+ func (_DevicesStorage *DevicesStorageSession) RenounceOwnership() (*types.Transaction, error)

+ func (_DevicesStorage *DevicesStorageSession) SetDevices(_deviceList []byte) (*types.Transaction, error)

+ func (_DevicesStorage *DevicesStorageSession) Touch(_hash [32]byte) (*types.Transaction, error)

+ func (_DevicesStorage *DevicesStorageSession) TransferOwnership(_newOwner common.Address) (*types.Transaction, error)

+ type DevicesStorageSuicide struct

+ Block *big.Int

+ Raw types.Log

+ type DevicesStorageSuicideIterator struct

+ Event *DevicesStorageSuicide

+ func (it *DevicesStorageSuicideIterator) Close() error

+ func (it *DevicesStorageSuicideIterator) Error() error

+ func (it *DevicesStorageSuicideIterator) Next() bool

+ type DevicesStorageTransactor struct

+ func NewDevicesStorageTransactor(address common.Address, transactor bind.ContractTransactor) (*DevicesStorageTransactor, error)

+ func (_DevicesStorage *DevicesStorageTransactor) KillDevicesStorage(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_DevicesStorage *DevicesStorageTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_DevicesStorage *DevicesStorageTransactor) SetDevices(opts *bind.TransactOpts, _deviceList []byte) (*types.Transaction, error)

+ func (_DevicesStorage *DevicesStorageTransactor) Touch(opts *bind.TransactOpts, _hash [32]byte) (*types.Transaction, error)

+ func (_DevicesStorage *DevicesStorageTransactor) TransferOwnership(opts *bind.TransactOpts, _newOwner common.Address) (*types.Transaction, error)

+ type DevicesStorageTransactorRaw struct

+ Contract *DevicesStorageTransactor

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

+ func (_DevicesStorage *DevicesStorageTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DevicesStorageTransactorSession struct

+ Contract *DevicesStorageTransactor

+ TransactOpts bind.TransactOpts

+ func (_DevicesStorage *DevicesStorageTransactorSession) KillDevicesStorage() (*types.Transaction, error)

+ func (_DevicesStorage *DevicesStorageTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_DevicesStorage *DevicesStorageTransactorSession) SetDevices(_deviceList []byte) (*types.Transaction, error)

+ func (_DevicesStorage *DevicesStorageTransactorSession) Touch(_hash [32]byte) (*types.Transaction, error)

+ func (_DevicesStorage *DevicesStorageTransactorSession) TransferOwnership(_newOwner common.Address) (*types.Transaction, error)

type MigrationsFilterer

+ func (_Migrations *MigrationsFilterer) FilterOwnershipRenounced(opts *bind.FilterOpts, previousOwner []common.Address) (*MigrationsOwnershipRenouncedIterator, error)

+ func (_Migrations *MigrationsFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*MigrationsOwnershipTransferredIterator, error)

+ func (_Migrations *MigrationsFilterer) WatchOwnershipRenounced(opts *bind.WatchOpts, sink chan<- *MigrationsOwnershipRenounced, ...) (event.Subscription, error)

+ func (_Migrations *MigrationsFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *MigrationsOwnershipTransferred, ...) (event.Subscription, error)

+ type MigrationsOwnershipRenounced struct

+ PreviousOwner common.Address

+ Raw types.Log

+ type MigrationsOwnershipRenouncedIterator struct

+ Event *MigrationsOwnershipRenounced

+ func (it *MigrationsOwnershipRenouncedIterator) Close() error

+ func (it *MigrationsOwnershipRenouncedIterator) Error() error

+ func (it *MigrationsOwnershipRenouncedIterator) Next() bool

+ type MigrationsOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type MigrationsOwnershipTransferredIterator struct

+ Event *MigrationsOwnershipTransferred

+ func (it *MigrationsOwnershipTransferredIterator) Close() error

+ func (it *MigrationsOwnershipTransferredIterator) Error() error

+ func (it *MigrationsOwnershipTransferredIterator) Next() bool

type MigrationsSession

+ func (_Migrations *MigrationsSession) RenounceOwnership() (*types.Transaction, error)

+ func (_Migrations *MigrationsSession) TransferOwnership(_newOwner common.Address) (*types.Transaction, error)

type MigrationsTransactor

+ func (_Migrations *MigrationsTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Migrations *MigrationsTransactor) TransferOwnership(opts *bind.TransactOpts, _newOwner common.Address) (*types.Transaction, error)

type MigrationsTransactorSession

+ func (_Migrations *MigrationsTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_Migrations *MigrationsTransactorSession) TransferOwnership(_newOwner common.Address) (*types.Transaction, error)

v0.4.20

Dec 14, 2018

v0.4.19

Nov 29, 2018

v0.4.18

Nov 28, 2018

v0.4.17

Nov 28, 2018

Changes in this version

type AddressHashMapFilterer

+ func (_AddressHashMap *AddressHashMapFilterer) FilterOwnershipRenounced(opts *bind.FilterOpts, previousOwner []common.Address) (*AddressHashMapOwnershipRenouncedIterator, error)

+ func (_AddressHashMap *AddressHashMapFilterer) WatchOwnershipRenounced(opts *bind.WatchOpts, sink chan<- *AddressHashMapOwnershipRenounced, ...) (event.Subscription, error)

+ type AddressHashMapOwnershipRenounced struct

+ PreviousOwner common.Address

+ Raw types.Log

+ type AddressHashMapOwnershipRenouncedIterator struct

+ Event *AddressHashMapOwnershipRenounced

+ func (it *AddressHashMapOwnershipRenouncedIterator) Close() error

+ func (it *AddressHashMapOwnershipRenouncedIterator) Error() error

+ func (it *AddressHashMapOwnershipRenouncedIterator) Next() bool

type AddressHashMapSession

+ func (_AddressHashMap *AddressHashMapSession) RenounceOwnership() (*types.Transaction, error)

type AddressHashMapTransactor

+ func (_AddressHashMap *AddressHashMapTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

type AddressHashMapTransactorSession

+ func (_AddressHashMap *AddressHashMapTransactorSession) RenounceOwnership() (*types.Transaction, error)

type BlacklistFilterer

+ func (_Blacklist *BlacklistFilterer) FilterOwnershipRenounced(opts *bind.FilterOpts, previousOwner []common.Address) (*BlacklistOwnershipRenouncedIterator, error)

+ func (_Blacklist *BlacklistFilterer) WatchOwnershipRenounced(opts *bind.WatchOpts, sink chan<- *BlacklistOwnershipRenounced, ...) (event.Subscription, error)

+ type BlacklistOwnershipRenounced struct

+ PreviousOwner common.Address

+ Raw types.Log

+ type BlacklistOwnershipRenouncedIterator struct

+ Event *BlacklistOwnershipRenounced

+ func (it *BlacklistOwnershipRenouncedIterator) Close() error

+ func (it *BlacklistOwnershipRenouncedIterator) Error() error

+ func (it *BlacklistOwnershipRenouncedIterator) Next() bool

type BlacklistSession

+ func (_Blacklist *BlacklistSession) RenounceOwnership() (*types.Transaction, error)

type BlacklistTransactor

+ func (_Blacklist *BlacklistTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

type BlacklistTransactorSession

+ func (_Blacklist *BlacklistTransactorSession) RenounceOwnership() (*types.Transaction, error)

type DeployListFilterer

+ func (_DeployList *DeployListFilterer) FilterOwnershipRenounced(opts *bind.FilterOpts, previousOwner []common.Address) (*DeployListOwnershipRenouncedIterator, error)

+ func (_DeployList *DeployListFilterer) WatchOwnershipRenounced(opts *bind.WatchOpts, sink chan<- *DeployListOwnershipRenounced, ...) (event.Subscription, error)

+ type DeployListOwnershipRenounced struct

+ PreviousOwner common.Address

+ Raw types.Log

+ type DeployListOwnershipRenouncedIterator struct

+ Event *DeployListOwnershipRenounced

+ func (it *DeployListOwnershipRenouncedIterator) Close() error

+ func (it *DeployListOwnershipRenouncedIterator) Error() error

+ func (it *DeployListOwnershipRenouncedIterator) Next() bool

type DeployListSession

+ func (_DeployList *DeployListSession) RenounceOwnership() (*types.Transaction, error)

type DeployListTransactor

+ func (_DeployList *DeployListTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

type DeployListTransactorSession

+ func (_DeployList *DeployListTransactorSession) RenounceOwnership() (*types.Transaction, error)

type MarketFilterer

+ func (_Market *MarketFilterer) FilterOwnershipRenounced(opts *bind.FilterOpts, previousOwner []common.Address) (*MarketOwnershipRenouncedIterator, error)

+ func (_Market *MarketFilterer) WatchOwnershipRenounced(opts *bind.WatchOpts, sink chan<- *MarketOwnershipRenounced, ...) (event.Subscription, error)

+ type MarketOwnershipRenounced struct

+ PreviousOwner common.Address

+ Raw types.Log

+ type MarketOwnershipRenouncedIterator struct

+ Event *MarketOwnershipRenounced

+ func (it *MarketOwnershipRenouncedIterator) Close() error

+ func (it *MarketOwnershipRenouncedIterator) Error() error

+ func (it *MarketOwnershipRenouncedIterator) Next() bool

type MarketSession

+ func (_Market *MarketSession) KillMarket() (*types.Transaction, error)

+ func (_Market *MarketSession) RenounceOwnership() (*types.Transaction, error)

type MarketTransactor

+ func (_Market *MarketTransactor) KillMarket(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Market *MarketTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

type MarketTransactorSession

+ func (_Market *MarketTransactorSession) KillMarket() (*types.Transaction, error)

+ func (_Market *MarketTransactorSession) RenounceOwnership() (*types.Transaction, error)

type MigrationsCaller

+ func (_Migrations *MigrationsCaller) LastCompletedMigration(opts *bind.CallOpts) (*big.Int, error)

type MigrationsCallerSession

+ func (_Migrations *MigrationsCallerSession) LastCompletedMigration() (*big.Int, error)

type MigrationsSession

+ func (_Migrations *MigrationsSession) LastCompletedMigration() (*big.Int, error)

type MultiSigWalletCaller

+ func (_MultiSigWallet *MultiSigWalletCaller) MAXOWNERCOUNT(opts *bind.CallOpts) (*big.Int, error)

type MultiSigWalletCallerSession

+ func (_MultiSigWallet *MultiSigWalletCallerSession) MAXOWNERCOUNT() (*big.Int, error)

type MultiSigWalletSession

+ func (_MultiSigWallet *MultiSigWalletSession) MAXOWNERCOUNT() (*big.Int, error)

type OracleUSDFilterer

+ func (_OracleUSD *OracleUSDFilterer) FilterOwnershipRenounced(opts *bind.FilterOpts, previousOwner []common.Address) (*OracleUSDOwnershipRenouncedIterator, error)

+ func (_OracleUSD *OracleUSDFilterer) WatchOwnershipRenounced(opts *bind.WatchOpts, sink chan<- *OracleUSDOwnershipRenounced, ...) (event.Subscription, error)

+ type OracleUSDOwnershipRenounced struct

+ PreviousOwner common.Address

+ Raw types.Log

+ type OracleUSDOwnershipRenouncedIterator struct

+ Event *OracleUSDOwnershipRenounced

+ func (it *OracleUSDOwnershipRenouncedIterator) Close() error

+ func (it *OracleUSDOwnershipRenouncedIterator) Error() error

+ func (it *OracleUSDOwnershipRenouncedIterator) Next() bool

type OracleUSDSession

+ func (_OracleUSD *OracleUSDSession) RenounceOwnership() (*types.Transaction, error)

type OracleUSDTransactor

+ func (_OracleUSD *OracleUSDTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

type OracleUSDTransactorSession

+ func (_OracleUSD *OracleUSDTransactorSession) RenounceOwnership() (*types.Transaction, error)

type OwnableFilterer

+ func (_Ownable *OwnableFilterer) FilterOwnershipRenounced(opts *bind.FilterOpts, previousOwner []common.Address) (*OwnableOwnershipRenouncedIterator, error)

+ func (_Ownable *OwnableFilterer) WatchOwnershipRenounced(opts *bind.WatchOpts, sink chan<- *OwnableOwnershipRenounced, ...) (event.Subscription, error)

+ type OwnableOwnershipRenounced struct

+ PreviousOwner common.Address

+ Raw types.Log

+ type OwnableOwnershipRenouncedIterator struct

+ Event *OwnableOwnershipRenounced

+ func (it *OwnableOwnershipRenouncedIterator) Close() error

+ func (it *OwnableOwnershipRenouncedIterator) Error() error

+ func (it *OwnableOwnershipRenouncedIterator) Next() bool

type OwnableSession

+ func (_Ownable *OwnableSession) RenounceOwnership() (*types.Transaction, error)

type OwnableTransactor

+ func (_Ownable *OwnableTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

type OwnableTransactorSession

+ func (_Ownable *OwnableTransactorSession) RenounceOwnership() (*types.Transaction, error)

type PausableFilterer

+ func (_Pausable *PausableFilterer) FilterOwnershipRenounced(opts *bind.FilterOpts, previousOwner []common.Address) (*PausableOwnershipRenouncedIterator, error)

+ func (_Pausable *PausableFilterer) WatchOwnershipRenounced(opts *bind.WatchOpts, sink chan<- *PausableOwnershipRenounced, ...) (event.Subscription, error)

+ type PausableOwnershipRenounced struct

+ PreviousOwner common.Address

+ Raw types.Log

+ type PausableOwnershipRenouncedIterator struct

+ Event *PausableOwnershipRenounced

+ func (it *PausableOwnershipRenouncedIterator) Close() error

+ func (it *PausableOwnershipRenouncedIterator) Error() error

+ func (it *PausableOwnershipRenouncedIterator) Next() bool

type PausableSession

+ func (_Pausable *PausableSession) RenounceOwnership() (*types.Transaction, error)

type PausableTransactor

+ func (_Pausable *PausableTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

type PausableTransactorSession

+ func (_Pausable *PausableTransactorSession) RenounceOwnership() (*types.Transaction, error)

type ProfileRegistryFilterer

+ func (_ProfileRegistry *ProfileRegistryFilterer) FilterOwnershipRenounced(opts *bind.FilterOpts, previousOwner []common.Address) (*ProfileRegistryOwnershipRenouncedIterator, error)

+ func (_ProfileRegistry *ProfileRegistryFilterer) WatchOwnershipRenounced(opts *bind.WatchOpts, sink chan<- *ProfileRegistryOwnershipRenounced, ...) (event.Subscription, error)

+ type ProfileRegistryOwnershipRenounced struct

+ PreviousOwner common.Address

+ Raw types.Log

+ type ProfileRegistryOwnershipRenouncedIterator struct

+ Event *ProfileRegistryOwnershipRenounced

+ func (it *ProfileRegistryOwnershipRenouncedIterator) Close() error

+ func (it *ProfileRegistryOwnershipRenouncedIterator) Error() error

+ func (it *ProfileRegistryOwnershipRenouncedIterator) Next() bool

type ProfileRegistrySession

+ func (_ProfileRegistry *ProfileRegistrySession) RenounceOwnership() (*types.Transaction, error)

type ProfileRegistryTransactor

+ func (_ProfileRegistry *ProfileRegistryTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

type ProfileRegistryTransactorSession

+ func (_ProfileRegistry *ProfileRegistryTransactorSession) RenounceOwnership() (*types.Transaction, error)

type SNMFilterer

+ func (_SNM *SNMFilterer) FilterOwnershipRenounced(opts *bind.FilterOpts, previousOwner []common.Address) (*SNMOwnershipRenouncedIterator, error)

+ func (_SNM *SNMFilterer) WatchOwnershipRenounced(opts *bind.WatchOpts, sink chan<- *SNMOwnershipRenounced, ...) (event.Subscription, error)

+ type SNMOwnershipRenounced struct

+ PreviousOwner common.Address

+ Raw types.Log

+ type SNMOwnershipRenouncedIterator struct

+ Event *SNMOwnershipRenounced

+ func (it *SNMOwnershipRenouncedIterator) Close() error

+ func (it *SNMOwnershipRenouncedIterator) Error() error

+ func (it *SNMOwnershipRenouncedIterator) Next() bool

type SNMSession

+ func (_SNM *SNMSession) RenounceOwnership() (*types.Transaction, error)

type SNMTransactor

+ func (_SNM *SNMTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

type SNMTransactorSession

+ func (_SNM *SNMTransactorSession) RenounceOwnership() (*types.Transaction, error)

type SimpleGatekeeperWithLimitFilterer

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitFilterer) FilterOwnershipRenounced(opts *bind.FilterOpts, previousOwner []common.Address) (*SimpleGatekeeperWithLimitOwnershipRenouncedIterator, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitFilterer) WatchOwnershipRenounced(opts *bind.WatchOpts, sink chan<- *SimpleGatekeeperWithLimitOwnershipRenounced, ...) (event.Subscription, error)

type SimpleGatekeeperWithLimitLiveFilterer

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveFilterer) FilterOwnershipRenounced(opts *bind.FilterOpts, previousOwner []common.Address) (*SimpleGatekeeperWithLimitLiveOwnershipRenouncedIterator, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveFilterer) WatchOwnershipRenounced(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ type SimpleGatekeeperWithLimitLiveOwnershipRenounced struct

+ PreviousOwner common.Address

+ Raw types.Log

+ type SimpleGatekeeperWithLimitLiveOwnershipRenouncedIterator struct

+ Event *SimpleGatekeeperWithLimitLiveOwnershipRenounced

+ func (it *SimpleGatekeeperWithLimitLiveOwnershipRenouncedIterator) Close() error

+ func (it *SimpleGatekeeperWithLimitLiveOwnershipRenouncedIterator) Error() error

+ func (it *SimpleGatekeeperWithLimitLiveOwnershipRenouncedIterator) Next() bool

type SimpleGatekeeperWithLimitLiveSession

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveSession) RenounceOwnership() (*types.Transaction, error)

type SimpleGatekeeperWithLimitLiveTransactor

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

type SimpleGatekeeperWithLimitLiveTransactorSession

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ type SimpleGatekeeperWithLimitOwnershipRenounced struct

+ PreviousOwner common.Address

+ Raw types.Log

+ type SimpleGatekeeperWithLimitOwnershipRenouncedIterator struct

+ Event *SimpleGatekeeperWithLimitOwnershipRenounced

+ func (it *SimpleGatekeeperWithLimitOwnershipRenouncedIterator) Close() error

+ func (it *SimpleGatekeeperWithLimitOwnershipRenouncedIterator) Error() error

+ func (it *SimpleGatekeeperWithLimitOwnershipRenouncedIterator) Next() bool

type SimpleGatekeeperWithLimitSession

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitSession) PayinTargeted(_value *big.Int, _target common.Address) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitSession) RenounceOwnership() (*types.Transaction, error)

type SimpleGatekeeperWithLimitTransactor

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactor) PayinTargeted(opts *bind.TransactOpts, _value *big.Int, _target common.Address) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

type SimpleGatekeeperWithLimitTransactorSession

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactorSession) PayinTargeted(_value *big.Int, _target common.Address) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactorSession) RenounceOwnership() (*types.Transaction, error)

type TestnetFaucetFilterer

+ func (_TestnetFaucet *TestnetFaucetFilterer) FilterOwnershipRenounced(opts *bind.FilterOpts, previousOwner []common.Address) (*TestnetFaucetOwnershipRenouncedIterator, error)

+ func (_TestnetFaucet *TestnetFaucetFilterer) WatchOwnershipRenounced(opts *bind.WatchOpts, sink chan<- *TestnetFaucetOwnershipRenounced, ...) (event.Subscription, error)

+ type TestnetFaucetOwnershipRenounced struct

+ PreviousOwner common.Address

+ Raw types.Log

+ type TestnetFaucetOwnershipRenouncedIterator struct

+ Event *TestnetFaucetOwnershipRenounced

+ func (it *TestnetFaucetOwnershipRenouncedIterator) Close() error

+ func (it *TestnetFaucetOwnershipRenouncedIterator) Error() error

+ func (it *TestnetFaucetOwnershipRenouncedIterator) Next() bool

type TestnetFaucetSession

+ func (_TestnetFaucet *TestnetFaucetSession) RenounceOwnership() (*types.Transaction, error)

type TestnetFaucetTransactor

+ func (_TestnetFaucet *TestnetFaucetTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

type TestnetFaucetTransactorSession

+ func (_TestnetFaucet *TestnetFaucetTransactorSession) RenounceOwnership() (*types.Transaction, error)

v0.4.16

Nov 19, 2018

v0.4.15

Nov 16, 2018

v0.4.14

Oct 23, 2018

v0.4.13

Oct 18, 2018

v0.4.12

Oct 2, 2018

v0.4.11

Sep 19, 2018

v0.4.10

Aug 30, 2018

v0.4.9

Aug 15, 2018

v0.4.8

Aug 7, 2018

v0.4.7

Aug 3, 2018

v0.4.6

Aug 1, 2018

v0.4.5

Jul 24, 2018

v0.4.4

Jul 9, 2018

v0.4.3

Jul 3, 2018

v0.4.2

Jun 30, 2018

v0.4.1

Jun 30, 2018

Changes in this version

+ const AddressHashMapABI

+ const AddressHashMapBin

+ const BasicTokenABI

+ const BasicTokenBin

+ const BlacklistABI

+ const BlacklistBin

+ const DeployListABI

+ const DeployListBin

+ const ERC20ABI

+ const ERC20BasicABI

+ const ERC20BasicBin

+ const ERC20Bin

+ const MarketABI

+ const MarketBin

+ const MigrationsABI

+ const MigrationsBin

+ const MultiSigWalletABI

+ const MultiSigWalletBin

+ const OracleUSDABI

+ const OracleUSDBin

+ const OwnableABI

+ const OwnableBin

+ const PausableABI

+ const PausableBin

+ const ProfileRegistryABI

+ const ProfileRegistryBin

+ const SNMABI

+ const SNMBin

+ const SNMDABI

+ const SNMDBin

+ const SNMMasterchainABI

+ const SNMMasterchainBin

+ const SNMTTokenABI

+ const SNMTTokenBin

+ const SafeMathABI

+ const SafeMathBin

+ const SimpleGatekeeperABI

+ const SimpleGatekeeperBin

+ const SimpleGatekeeperWithLimitABI

+ const SimpleGatekeeperWithLimitBin

+ const SimpleGatekeeperWithLimitLiveABI

+ const SimpleGatekeeperWithLimitLiveBin

+ const StandardTokenABI

+ const StandardTokenBin

+ const TestnetFaucetABI

+ const TestnetFaucetBin

+ type AddressHashMap struct

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

+ func NewAddressHashMap(address common.Address, backend bind.ContractBackend) (*AddressHashMap, error)

+ type AddressHashMapCaller struct

+ func NewAddressHashMapCaller(address common.Address, caller bind.ContractCaller) (*AddressHashMapCaller, error)

+ func (_AddressHashMap *AddressHashMapCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_AddressHashMap *AddressHashMapCaller) Read(opts *bind.CallOpts, _key [32]byte) (common.Address, error)

+ type AddressHashMapCallerRaw struct

+ Contract *AddressHashMapCaller

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

+ type AddressHashMapCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *AddressHashMapCaller

+ func (_AddressHashMap *AddressHashMapCallerSession) Owner() (common.Address, error)

+ func (_AddressHashMap *AddressHashMapCallerSession) Read(_key [32]byte) (common.Address, error)

+ type AddressHashMapFilterer struct

+ func NewAddressHashMapFilterer(address common.Address, filterer bind.ContractFilterer) (*AddressHashMapFilterer, error)

+ func (_AddressHashMap *AddressHashMapFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*AddressHashMapOwnershipTransferredIterator, error)

+ func (_AddressHashMap *AddressHashMapFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *AddressHashMapOwnershipTransferred, ...) (event.Subscription, error)

+ type AddressHashMapOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type AddressHashMapOwnershipTransferredIterator struct

+ Event *AddressHashMapOwnershipTransferred

+ func (it *AddressHashMapOwnershipTransferredIterator) Close() error

+ func (it *AddressHashMapOwnershipTransferredIterator) Error() error

+ func (it *AddressHashMapOwnershipTransferredIterator) Next() bool

+ type AddressHashMapRaw struct

+ Contract *AddressHashMap

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

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

+ func (_AddressHashMap *AddressHashMapRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AddressHashMapSession struct

+ CallOpts bind.CallOpts

+ Contract *AddressHashMap

+ TransactOpts bind.TransactOpts

+ func (_AddressHashMap *AddressHashMapSession) Owner() (common.Address, error)

+ func (_AddressHashMap *AddressHashMapSession) Read(_key [32]byte) (common.Address, error)

+ func (_AddressHashMap *AddressHashMapSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_AddressHashMap *AddressHashMapSession) Write(_key [32]byte, _value common.Address) (*types.Transaction, error)

+ type AddressHashMapTransactor struct

+ func NewAddressHashMapTransactor(address common.Address, transactor bind.ContractTransactor) (*AddressHashMapTransactor, error)

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

+ func (_AddressHashMap *AddressHashMapTransactor) Write(opts *bind.TransactOpts, _key [32]byte, _value common.Address) (*types.Transaction, error)

+ type AddressHashMapTransactorRaw struct

+ Contract *AddressHashMapTransactor

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

+ func (_AddressHashMap *AddressHashMapTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AddressHashMapTransactorSession struct

+ Contract *AddressHashMapTransactor

+ TransactOpts bind.TransactOpts

+ func (_AddressHashMap *AddressHashMapTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_AddressHashMap *AddressHashMapTransactorSession) Write(_key [32]byte, _value common.Address) (*types.Transaction, error)

+ type BasicToken struct

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

+ func NewBasicToken(address common.Address, backend bind.ContractBackend) (*BasicToken, error)

+ type BasicTokenCaller struct

+ func NewBasicTokenCaller(address common.Address, caller bind.ContractCaller) (*BasicTokenCaller, error)

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

+ func (_BasicToken *BasicTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type BasicTokenCallerRaw struct

+ Contract *BasicTokenCaller

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

+ type BasicTokenCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *BasicTokenCaller

+ func (_BasicToken *BasicTokenCallerSession) BalanceOf(_owner common.Address) (*big.Int, error)

+ func (_BasicToken *BasicTokenCallerSession) TotalSupply() (*big.Int, error)

+ type BasicTokenFilterer struct

+ func NewBasicTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*BasicTokenFilterer, error)

+ func (_BasicToken *BasicTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*BasicTokenTransferIterator, error)

+ func (_BasicToken *BasicTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *BasicTokenTransfer, from []common.Address, ...) (event.Subscription, error)

+ type BasicTokenRaw struct

+ Contract *BasicToken

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

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

+ func (_BasicToken *BasicTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BasicTokenSession struct

+ CallOpts bind.CallOpts

+ Contract *BasicToken

+ TransactOpts bind.TransactOpts

+ func (_BasicToken *BasicTokenSession) BalanceOf(_owner common.Address) (*big.Int, error)

+ func (_BasicToken *BasicTokenSession) TotalSupply() (*big.Int, error)

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

+ type BasicTokenTransactor struct

+ func NewBasicTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*BasicTokenTransactor, error)

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

+ type BasicTokenTransactorRaw struct

+ Contract *BasicTokenTransactor

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

+ func (_BasicToken *BasicTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BasicTokenTransactorSession struct

+ Contract *BasicTokenTransactor

+ TransactOpts bind.TransactOpts

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

+ type BasicTokenTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type BasicTokenTransferIterator struct

+ Event *BasicTokenTransfer

+ func (it *BasicTokenTransferIterator) Close() error

+ func (it *BasicTokenTransferIterator) Error() error

+ func (it *BasicTokenTransferIterator) Next() bool

+ type Blacklist struct

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

+ func NewBlacklist(address common.Address, backend bind.ContractBackend) (*Blacklist, error)

+ type BlacklistAddedToBlacklist struct

+ Addee common.Address

+ Adder common.Address

+ Raw types.Log

+ type BlacklistAddedToBlacklistIterator struct

+ Event *BlacklistAddedToBlacklist

+ func (it *BlacklistAddedToBlacklistIterator) Close() error

+ func (it *BlacklistAddedToBlacklistIterator) Error() error

+ func (it *BlacklistAddedToBlacklistIterator) Next() bool

+ type BlacklistCaller struct

+ func NewBlacklistCaller(address common.Address, caller bind.ContractCaller) (*BlacklistCaller, error)

+ func (_Blacklist *BlacklistCaller) Check(opts *bind.CallOpts, _who common.Address, _whom common.Address) (bool, error)

+ func (_Blacklist *BlacklistCaller) Market(opts *bind.CallOpts) (common.Address, error)

+ func (_Blacklist *BlacklistCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ type BlacklistCallerRaw struct

+ Contract *BlacklistCaller

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

+ type BlacklistCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *BlacklistCaller

+ func (_Blacklist *BlacklistCallerSession) Check(_who common.Address, _whom common.Address) (bool, error)

+ func (_Blacklist *BlacklistCallerSession) Market() (common.Address, error)

+ func (_Blacklist *BlacklistCallerSession) Owner() (common.Address, error)

+ type BlacklistFilterer struct

+ func NewBlacklistFilterer(address common.Address, filterer bind.ContractFilterer) (*BlacklistFilterer, error)

+ func (_Blacklist *BlacklistFilterer) FilterAddedToBlacklist(opts *bind.FilterOpts, adder []common.Address, addee []common.Address) (*BlacklistAddedToBlacklistIterator, error)

+ func (_Blacklist *BlacklistFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*BlacklistOwnershipTransferredIterator, error)

+ func (_Blacklist *BlacklistFilterer) FilterRemovedFromBlacklist(opts *bind.FilterOpts, remover []common.Address, removee []common.Address) (*BlacklistRemovedFromBlacklistIterator, error)

+ func (_Blacklist *BlacklistFilterer) WatchAddedToBlacklist(opts *bind.WatchOpts, sink chan<- *BlacklistAddedToBlacklist, ...) (event.Subscription, error)

+ func (_Blacklist *BlacklistFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *BlacklistOwnershipTransferred, ...) (event.Subscription, error)

+ func (_Blacklist *BlacklistFilterer) WatchRemovedFromBlacklist(opts *bind.WatchOpts, sink chan<- *BlacklistRemovedFromBlacklist, ...) (event.Subscription, error)

+ type BlacklistOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type BlacklistOwnershipTransferredIterator struct

+ Event *BlacklistOwnershipTransferred

+ func (it *BlacklistOwnershipTransferredIterator) Close() error

+ func (it *BlacklistOwnershipTransferredIterator) Error() error

+ func (it *BlacklistOwnershipTransferredIterator) Next() bool

+ type BlacklistRaw struct

+ Contract *Blacklist

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

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

+ func (_Blacklist *BlacklistRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BlacklistRemovedFromBlacklist struct

+ Raw types.Log

+ Removee common.Address

+ Remover common.Address

+ type BlacklistRemovedFromBlacklistIterator struct

+ Event *BlacklistRemovedFromBlacklist

+ func (it *BlacklistRemovedFromBlacklistIterator) Close() error

+ func (it *BlacklistRemovedFromBlacklistIterator) Error() error

+ func (it *BlacklistRemovedFromBlacklistIterator) Next() bool

+ type BlacklistSession struct

+ CallOpts bind.CallOpts

+ Contract *Blacklist

+ TransactOpts bind.TransactOpts

+ func (_Blacklist *BlacklistSession) Add(_who common.Address, _whom common.Address) (*types.Transaction, error)

+ func (_Blacklist *BlacklistSession) AddMaster(_root common.Address) (*types.Transaction, error)

+ func (_Blacklist *BlacklistSession) Check(_who common.Address, _whom common.Address) (bool, error)

+ func (_Blacklist *BlacklistSession) Market() (common.Address, error)

+ func (_Blacklist *BlacklistSession) Owner() (common.Address, error)

+ func (_Blacklist *BlacklistSession) Remove(_whom common.Address) (*types.Transaction, error)

+ func (_Blacklist *BlacklistSession) RemoveMaster(_root common.Address) (*types.Transaction, error)

+ func (_Blacklist *BlacklistSession) SetMarketAddress(_market common.Address) (*types.Transaction, error)

+ func (_Blacklist *BlacklistSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type BlacklistTransactor struct

+ func NewBlacklistTransactor(address common.Address, transactor bind.ContractTransactor) (*BlacklistTransactor, error)

+ func (_Blacklist *BlacklistTransactor) Add(opts *bind.TransactOpts, _who common.Address, _whom common.Address) (*types.Transaction, error)

+ func (_Blacklist *BlacklistTransactor) AddMaster(opts *bind.TransactOpts, _root common.Address) (*types.Transaction, error)

+ func (_Blacklist *BlacklistTransactor) Remove(opts *bind.TransactOpts, _whom common.Address) (*types.Transaction, error)

+ func (_Blacklist *BlacklistTransactor) RemoveMaster(opts *bind.TransactOpts, _root common.Address) (*types.Transaction, error)

+ func (_Blacklist *BlacklistTransactor) SetMarketAddress(opts *bind.TransactOpts, _market common.Address) (*types.Transaction, error)

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

+ type BlacklistTransactorRaw struct

+ Contract *BlacklistTransactor

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

+ func (_Blacklist *BlacklistTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type BlacklistTransactorSession struct

+ Contract *BlacklistTransactor

+ TransactOpts bind.TransactOpts

+ func (_Blacklist *BlacklistTransactorSession) Add(_who common.Address, _whom common.Address) (*types.Transaction, error)

+ func (_Blacklist *BlacklistTransactorSession) AddMaster(_root common.Address) (*types.Transaction, error)

+ func (_Blacklist *BlacklistTransactorSession) Remove(_whom common.Address) (*types.Transaction, error)

+ func (_Blacklist *BlacklistTransactorSession) RemoveMaster(_root common.Address) (*types.Transaction, error)

+ func (_Blacklist *BlacklistTransactorSession) SetMarketAddress(_market common.Address) (*types.Transaction, error)

+ func (_Blacklist *BlacklistTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type DeployList struct

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

+ func NewDeployList(address common.Address, backend bind.ContractBackend) (*DeployList, error)

+ type DeployListCaller struct

+ func NewDeployListCaller(address common.Address, caller bind.ContractCaller) (*DeployListCaller, error)

+ func (_DeployList *DeployListCaller) GetDeployers(opts *bind.CallOpts) ([]common.Address, error)

+ func (_DeployList *DeployListCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ type DeployListCallerRaw struct

+ Contract *DeployListCaller

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

+ type DeployListCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *DeployListCaller

+ func (_DeployList *DeployListCallerSession) GetDeployers() ([]common.Address, error)

+ func (_DeployList *DeployListCallerSession) Owner() (common.Address, error)

+ type DeployListDeployerAdded struct

+ Deployer common.Address

+ Raw types.Log

+ type DeployListDeployerAddedIterator struct

+ Event *DeployListDeployerAdded

+ func (it *DeployListDeployerAddedIterator) Close() error

+ func (it *DeployListDeployerAddedIterator) Error() error

+ func (it *DeployListDeployerAddedIterator) Next() bool

+ type DeployListDeployerRemoved struct

+ Deployer common.Address

+ Raw types.Log

+ type DeployListDeployerRemovedIterator struct

+ Event *DeployListDeployerRemoved

+ func (it *DeployListDeployerRemovedIterator) Close() error

+ func (it *DeployListDeployerRemovedIterator) Error() error

+ func (it *DeployListDeployerRemovedIterator) Next() bool

+ type DeployListFilterer struct

+ func NewDeployListFilterer(address common.Address, filterer bind.ContractFilterer) (*DeployListFilterer, error)

+ func (_DeployList *DeployListFilterer) FilterDeployerAdded(opts *bind.FilterOpts) (*DeployListDeployerAddedIterator, error)

+ func (_DeployList *DeployListFilterer) FilterDeployerRemoved(opts *bind.FilterOpts) (*DeployListDeployerRemovedIterator, error)

+ func (_DeployList *DeployListFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*DeployListOwnershipTransferredIterator, error)

+ func (_DeployList *DeployListFilterer) WatchDeployerAdded(opts *bind.WatchOpts, sink chan<- *DeployListDeployerAdded) (event.Subscription, error)

+ func (_DeployList *DeployListFilterer) WatchDeployerRemoved(opts *bind.WatchOpts, sink chan<- *DeployListDeployerRemoved) (event.Subscription, error)

+ func (_DeployList *DeployListFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *DeployListOwnershipTransferred, ...) (event.Subscription, error)

+ type DeployListOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type DeployListOwnershipTransferredIterator struct

+ Event *DeployListOwnershipTransferred

+ func (it *DeployListOwnershipTransferredIterator) Close() error

+ func (it *DeployListOwnershipTransferredIterator) Error() error

+ func (it *DeployListOwnershipTransferredIterator) Next() bool

+ type DeployListRaw struct

+ Contract *DeployList

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

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

+ func (_DeployList *DeployListRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DeployListSession struct

+ CallOpts bind.CallOpts

+ Contract *DeployList

+ TransactOpts bind.TransactOpts

+ func (_DeployList *DeployListSession) AddDeployer(_deployer common.Address) (*types.Transaction, error)

+ func (_DeployList *DeployListSession) GetDeployers() ([]common.Address, error)

+ func (_DeployList *DeployListSession) Owner() (common.Address, error)

+ func (_DeployList *DeployListSession) RemoveDeployer(_deployer common.Address) (*types.Transaction, error)

+ func (_DeployList *DeployListSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type DeployListTransactor struct

+ func NewDeployListTransactor(address common.Address, transactor bind.ContractTransactor) (*DeployListTransactor, error)

+ func (_DeployList *DeployListTransactor) AddDeployer(opts *bind.TransactOpts, _deployer common.Address) (*types.Transaction, error)

+ func (_DeployList *DeployListTransactor) RemoveDeployer(opts *bind.TransactOpts, _deployer common.Address) (*types.Transaction, error)

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

+ type DeployListTransactorRaw struct

+ Contract *DeployListTransactor

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

+ func (_DeployList *DeployListTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type DeployListTransactorSession struct

+ Contract *DeployListTransactor

+ TransactOpts bind.TransactOpts

+ func (_DeployList *DeployListTransactorSession) AddDeployer(_deployer common.Address) (*types.Transaction, error)

+ func (_DeployList *DeployListTransactorSession) RemoveDeployer(_deployer common.Address) (*types.Transaction, error)

+ func (_DeployList *DeployListTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type ERC20 struct

+ func DeployERC20(auth *bind.TransactOpts, backend bind.ContractBackend) (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 ERC20Basic struct

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

+ func NewERC20Basic(address common.Address, backend bind.ContractBackend) (*ERC20Basic, error)

+ type ERC20BasicCaller struct

+ func NewERC20BasicCaller(address common.Address, caller bind.ContractCaller) (*ERC20BasicCaller, error)

+ func (_ERC20Basic *ERC20BasicCaller) BalanceOf(opts *bind.CallOpts, who common.Address) (*big.Int, error)

+ func (_ERC20Basic *ERC20BasicCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type ERC20BasicCallerRaw struct

+ Contract *ERC20BasicCaller

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

+ type ERC20BasicCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC20BasicCaller

+ func (_ERC20Basic *ERC20BasicCallerSession) BalanceOf(who common.Address) (*big.Int, error)

+ func (_ERC20Basic *ERC20BasicCallerSession) TotalSupply() (*big.Int, error)

+ type ERC20BasicFilterer struct

+ func NewERC20BasicFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20BasicFilterer, error)

+ func (_ERC20Basic *ERC20BasicFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20BasicTransferIterator, error)

+ func (_ERC20Basic *ERC20BasicFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20BasicTransfer, from []common.Address, ...) (event.Subscription, error)

+ type ERC20BasicRaw struct

+ Contract *ERC20Basic

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

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

+ func (_ERC20Basic *ERC20BasicRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC20BasicSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC20Basic

+ TransactOpts bind.TransactOpts

+ func (_ERC20Basic *ERC20BasicSession) BalanceOf(who common.Address) (*big.Int, error)

+ func (_ERC20Basic *ERC20BasicSession) TotalSupply() (*big.Int, error)

+ func (_ERC20Basic *ERC20BasicSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error)

+ type ERC20BasicTransactor struct

+ func NewERC20BasicTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20BasicTransactor, error)

+ func (_ERC20Basic *ERC20BasicTransactor) Transfer(opts *bind.TransactOpts, to common.Address, value *big.Int) (*types.Transaction, error)

+ type ERC20BasicTransactorRaw struct

+ Contract *ERC20BasicTransactor

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

+ func (_ERC20Basic *ERC20BasicTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC20BasicTransactorSession struct

+ Contract *ERC20BasicTransactor

+ TransactOpts bind.TransactOpts

+ func (_ERC20Basic *ERC20BasicTransactorSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error)

+ type ERC20BasicTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type ERC20BasicTransferIterator struct

+ Event *ERC20BasicTransfer

+ func (it *ERC20BasicTransferIterator) Close() error

+ func (it *ERC20BasicTransferIterator) Error() error

+ func (it *ERC20BasicTransferIterator) 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) BalanceOf(opts *bind.CallOpts, who common.Address) (*big.Int, 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) BalanceOf(who common.Address) (*big.Int, 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 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) Approve(spender common.Address, value *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Session) BalanceOf(who common.Address) (*big.Int, 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 Market struct

+ func DeployMarket(auth *bind.TransactOpts, backend bind.ContractBackend, _token common.Address, ...) (common.Address, *types.Transaction, *Market, error)

+ func NewMarket(address common.Address, backend bind.ContractBackend) (*Market, error)

+ type MarketBilled struct

+ DealID *big.Int

+ PaidAmount *big.Int

+ Raw types.Log

+ type MarketBilledIterator struct

+ Event *MarketBilled

+ func (it *MarketBilledIterator) Close() error

+ func (it *MarketBilledIterator) Error() error

+ func (it *MarketBilledIterator) Next() bool

+ type MarketCaller struct

+ func NewMarketCaller(address common.Address, caller bind.ContractCaller) (*MarketCaller, error)

+ func (_Market *MarketCaller) Deals(opts *bind.CallOpts, arg0 *big.Int) (struct{ ... }, error)

+ func (_Market *MarketCaller) GetBenchmarksQuantity(opts *bind.CallOpts) (*big.Int, error)

+ func (_Market *MarketCaller) GetChangeRequestInfo(opts *bind.CallOpts, changeRequestID *big.Int) (struct{ ... }, error)

+ func (_Market *MarketCaller) GetChangeRequestsAmount(opts *bind.CallOpts) (*big.Int, error)

+ func (_Market *MarketCaller) GetDealInfo(opts *bind.CallOpts, dealID *big.Int) (struct{ ... }, error)

+ func (_Market *MarketCaller) GetDealParams(opts *bind.CallOpts, dealID *big.Int) (struct{ ... }, error)

+ func (_Market *MarketCaller) GetDealsAmount(opts *bind.CallOpts) (*big.Int, error)

+ func (_Market *MarketCaller) GetMaster(opts *bind.CallOpts, _worker common.Address) (common.Address, error)

+ func (_Market *MarketCaller) GetNetflagsQuantity(opts *bind.CallOpts) (*big.Int, error)

+ func (_Market *MarketCaller) GetOrderInfo(opts *bind.CallOpts, orderID *big.Int) (struct{ ... }, error)

+ func (_Market *MarketCaller) GetOrderParams(opts *bind.CallOpts, orderID *big.Int) (struct{ ... }, error)

+ func (_Market *MarketCaller) GetOrdersAmount(opts *bind.CallOpts) (*big.Int, error)

+ func (_Market *MarketCaller) Orders(opts *bind.CallOpts, arg0 *big.Int) (struct{ ... }, error)

+ func (_Market *MarketCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_Market *MarketCaller) Paused(opts *bind.CallOpts) (bool, error)

+ type MarketCallerRaw struct

+ Contract *MarketCaller

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

+ type MarketCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *MarketCaller

+ func (_Market *MarketCallerSession) Deals(arg0 *big.Int) (struct{ ... }, error)

+ func (_Market *MarketCallerSession) GetBenchmarksQuantity() (*big.Int, error)

+ func (_Market *MarketCallerSession) GetChangeRequestInfo(changeRequestID *big.Int) (struct{ ... }, error)

+ func (_Market *MarketCallerSession) GetChangeRequestsAmount() (*big.Int, error)

+ func (_Market *MarketCallerSession) GetDealInfo(dealID *big.Int) (struct{ ... }, error)

+ func (_Market *MarketCallerSession) GetDealParams(dealID *big.Int) (struct{ ... }, error)

+ func (_Market *MarketCallerSession) GetDealsAmount() (*big.Int, error)

+ func (_Market *MarketCallerSession) GetMaster(_worker common.Address) (common.Address, error)

+ func (_Market *MarketCallerSession) GetNetflagsQuantity() (*big.Int, error)

+ func (_Market *MarketCallerSession) GetOrderInfo(orderID *big.Int) (struct{ ... }, error)

+ func (_Market *MarketCallerSession) GetOrderParams(orderID *big.Int) (struct{ ... }, error)

+ func (_Market *MarketCallerSession) GetOrdersAmount() (*big.Int, error)

+ func (_Market *MarketCallerSession) Orders(arg0 *big.Int) (struct{ ... }, error)

+ func (_Market *MarketCallerSession) Owner() (common.Address, error)

+ func (_Market *MarketCallerSession) Paused() (bool, error)

+ type MarketDealChangeRequestSet struct

+ ChangeRequestID *big.Int

+ Raw types.Log

+ type MarketDealChangeRequestSetIterator struct

+ Event *MarketDealChangeRequestSet

+ func (it *MarketDealChangeRequestSetIterator) Close() error

+ func (it *MarketDealChangeRequestSetIterator) Error() error

+ func (it *MarketDealChangeRequestSetIterator) Next() bool

+ type MarketDealChangeRequestUpdated struct

+ ChangeRequestID *big.Int

+ Raw types.Log

+ type MarketDealChangeRequestUpdatedIterator struct

+ Event *MarketDealChangeRequestUpdated

+ func (it *MarketDealChangeRequestUpdatedIterator) Close() error

+ func (it *MarketDealChangeRequestUpdatedIterator) Error() error

+ func (it *MarketDealChangeRequestUpdatedIterator) Next() bool

+ type MarketDealOpened struct

+ DealID *big.Int

+ Raw types.Log

+ type MarketDealOpenedIterator struct

+ Event *MarketDealOpened

+ func (it *MarketDealOpenedIterator) Close() error

+ func (it *MarketDealOpenedIterator) Error() error

+ func (it *MarketDealOpenedIterator) Next() bool

+ type MarketDealUpdated struct

+ DealID *big.Int

+ Raw types.Log

+ type MarketDealUpdatedIterator struct

+ Event *MarketDealUpdated

+ func (it *MarketDealUpdatedIterator) Close() error

+ func (it *MarketDealUpdatedIterator) Error() error

+ func (it *MarketDealUpdatedIterator) Next() bool

+ type MarketFilterer struct

+ func NewMarketFilterer(address common.Address, filterer bind.ContractFilterer) (*MarketFilterer, error)

+ func (_Market *MarketFilterer) FilterBilled(opts *bind.FilterOpts, dealID []*big.Int, paidAmount []*big.Int) (*MarketBilledIterator, error)

+ func (_Market *MarketFilterer) FilterDealChangeRequestSet(opts *bind.FilterOpts, changeRequestID []*big.Int) (*MarketDealChangeRequestSetIterator, error)

+ func (_Market *MarketFilterer) FilterDealChangeRequestUpdated(opts *bind.FilterOpts, changeRequestID []*big.Int) (*MarketDealChangeRequestUpdatedIterator, error)

+ func (_Market *MarketFilterer) FilterDealOpened(opts *bind.FilterOpts, dealID []*big.Int) (*MarketDealOpenedIterator, error)

+ func (_Market *MarketFilterer) FilterDealUpdated(opts *bind.FilterOpts, dealID []*big.Int) (*MarketDealUpdatedIterator, error)

+ func (_Market *MarketFilterer) FilterNumBenchmarksUpdated(opts *bind.FilterOpts, newNum []*big.Int) (*MarketNumBenchmarksUpdatedIterator, error)

+ func (_Market *MarketFilterer) FilterNumNetflagsUpdated(opts *bind.FilterOpts, newNum []*big.Int) (*MarketNumNetflagsUpdatedIterator, error)

+ func (_Market *MarketFilterer) FilterOrderPlaced(opts *bind.FilterOpts, orderID []*big.Int) (*MarketOrderPlacedIterator, error)

+ func (_Market *MarketFilterer) FilterOrderUpdated(opts *bind.FilterOpts, orderID []*big.Int) (*MarketOrderUpdatedIterator, error)

+ func (_Market *MarketFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*MarketOwnershipTransferredIterator, error)

+ func (_Market *MarketFilterer) FilterPause(opts *bind.FilterOpts) (*MarketPauseIterator, error)

+ func (_Market *MarketFilterer) FilterUnpause(opts *bind.FilterOpts) (*MarketUnpauseIterator, error)

+ func (_Market *MarketFilterer) FilterWorkerAnnounced(opts *bind.FilterOpts, worker []common.Address, master []common.Address) (*MarketWorkerAnnouncedIterator, error)

+ func (_Market *MarketFilterer) FilterWorkerConfirmed(opts *bind.FilterOpts, worker []common.Address, master []common.Address) (*MarketWorkerConfirmedIterator, error)

+ func (_Market *MarketFilterer) FilterWorkerRemoved(opts *bind.FilterOpts, worker []common.Address, master []common.Address) (*MarketWorkerRemovedIterator, error)

+ func (_Market *MarketFilterer) WatchBilled(opts *bind.WatchOpts, sink chan<- *MarketBilled, dealID []*big.Int, ...) (event.Subscription, error)

+ func (_Market *MarketFilterer) WatchDealChangeRequestSet(opts *bind.WatchOpts, sink chan<- *MarketDealChangeRequestSet, ...) (event.Subscription, error)

+ func (_Market *MarketFilterer) WatchDealChangeRequestUpdated(opts *bind.WatchOpts, sink chan<- *MarketDealChangeRequestUpdated, ...) (event.Subscription, error)

+ func (_Market *MarketFilterer) WatchDealOpened(opts *bind.WatchOpts, sink chan<- *MarketDealOpened, dealID []*big.Int) (event.Subscription, error)

+ func (_Market *MarketFilterer) WatchDealUpdated(opts *bind.WatchOpts, sink chan<- *MarketDealUpdated, dealID []*big.Int) (event.Subscription, error)

+ func (_Market *MarketFilterer) WatchNumBenchmarksUpdated(opts *bind.WatchOpts, sink chan<- *MarketNumBenchmarksUpdated, ...) (event.Subscription, error)

+ func (_Market *MarketFilterer) WatchNumNetflagsUpdated(opts *bind.WatchOpts, sink chan<- *MarketNumNetflagsUpdated, newNum []*big.Int) (event.Subscription, error)

+ func (_Market *MarketFilterer) WatchOrderPlaced(opts *bind.WatchOpts, sink chan<- *MarketOrderPlaced, orderID []*big.Int) (event.Subscription, error)

+ func (_Market *MarketFilterer) WatchOrderUpdated(opts *bind.WatchOpts, sink chan<- *MarketOrderUpdated, orderID []*big.Int) (event.Subscription, error)

+ func (_Market *MarketFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *MarketOwnershipTransferred, ...) (event.Subscription, error)

+ func (_Market *MarketFilterer) WatchPause(opts *bind.WatchOpts, sink chan<- *MarketPause) (event.Subscription, error)

+ func (_Market *MarketFilterer) WatchUnpause(opts *bind.WatchOpts, sink chan<- *MarketUnpause) (event.Subscription, error)

+ func (_Market *MarketFilterer) WatchWorkerAnnounced(opts *bind.WatchOpts, sink chan<- *MarketWorkerAnnounced, ...) (event.Subscription, error)

+ func (_Market *MarketFilterer) WatchWorkerConfirmed(opts *bind.WatchOpts, sink chan<- *MarketWorkerConfirmed, ...) (event.Subscription, error)

+ func (_Market *MarketFilterer) WatchWorkerRemoved(opts *bind.WatchOpts, sink chan<- *MarketWorkerRemoved, ...) (event.Subscription, error)

+ type MarketNumBenchmarksUpdated struct

+ NewNum *big.Int

+ Raw types.Log

+ type MarketNumBenchmarksUpdatedIterator struct

+ Event *MarketNumBenchmarksUpdated

+ func (it *MarketNumBenchmarksUpdatedIterator) Close() error

+ func (it *MarketNumBenchmarksUpdatedIterator) Error() error

+ func (it *MarketNumBenchmarksUpdatedIterator) Next() bool

+ type MarketNumNetflagsUpdated struct

+ NewNum *big.Int

+ Raw types.Log

+ type MarketNumNetflagsUpdatedIterator struct

+ Event *MarketNumNetflagsUpdated

+ func (it *MarketNumNetflagsUpdatedIterator) Close() error

+ func (it *MarketNumNetflagsUpdatedIterator) Error() error

+ func (it *MarketNumNetflagsUpdatedIterator) Next() bool

+ type MarketOrderPlaced struct

+ OrderID *big.Int

+ Raw types.Log

+ type MarketOrderPlacedIterator struct

+ Event *MarketOrderPlaced

+ func (it *MarketOrderPlacedIterator) Close() error

+ func (it *MarketOrderPlacedIterator) Error() error

+ func (it *MarketOrderPlacedIterator) Next() bool

+ type MarketOrderUpdated struct

+ OrderID *big.Int

+ Raw types.Log

+ type MarketOrderUpdatedIterator struct

+ Event *MarketOrderUpdated

+ func (it *MarketOrderUpdatedIterator) Close() error

+ func (it *MarketOrderUpdatedIterator) Error() error

+ func (it *MarketOrderUpdatedIterator) Next() bool

+ type MarketOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type MarketOwnershipTransferredIterator struct

+ Event *MarketOwnershipTransferred

+ func (it *MarketOwnershipTransferredIterator) Close() error

+ func (it *MarketOwnershipTransferredIterator) Error() error

+ func (it *MarketOwnershipTransferredIterator) Next() bool

+ type MarketPause struct

+ Raw types.Log

+ type MarketPauseIterator struct

+ Event *MarketPause

+ func (it *MarketPauseIterator) Close() error

+ func (it *MarketPauseIterator) Error() error

+ func (it *MarketPauseIterator) Next() bool

+ type MarketRaw struct

+ Contract *Market

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

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

+ func (_Market *MarketRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MarketSession struct

+ CallOpts bind.CallOpts

+ Contract *Market

+ TransactOpts bind.TransactOpts

+ func (_Market *MarketSession) Bill(dealID *big.Int) (*types.Transaction, error)

+ func (_Market *MarketSession) CancelChangeRequest(changeRequestID *big.Int) (*types.Transaction, error)

+ func (_Market *MarketSession) CancelOrder(orderID *big.Int) (*types.Transaction, error)

+ func (_Market *MarketSession) CloseDeal(dealID *big.Int, blacklisted uint8) (*types.Transaction, error)

+ func (_Market *MarketSession) ConfirmWorker(_worker common.Address) (*types.Transaction, error)

+ func (_Market *MarketSession) CreateChangeRequest(dealID *big.Int, newPrice *big.Int, newDuration *big.Int) (*types.Transaction, error)

+ func (_Market *MarketSession) Deals(arg0 *big.Int) (struct{ ... }, error)

+ func (_Market *MarketSession) GetBenchmarksQuantity() (*big.Int, error)

+ func (_Market *MarketSession) GetChangeRequestInfo(changeRequestID *big.Int) (struct{ ... }, error)

+ func (_Market *MarketSession) GetChangeRequestsAmount() (*big.Int, error)

+ func (_Market *MarketSession) GetDealInfo(dealID *big.Int) (struct{ ... }, error)

+ func (_Market *MarketSession) GetDealParams(dealID *big.Int) (struct{ ... }, error)

+ func (_Market *MarketSession) GetDealsAmount() (*big.Int, error)

+ func (_Market *MarketSession) GetMaster(_worker common.Address) (common.Address, error)

+ func (_Market *MarketSession) GetNetflagsQuantity() (*big.Int, error)

+ func (_Market *MarketSession) GetOrderInfo(orderID *big.Int) (struct{ ... }, error)

+ func (_Market *MarketSession) GetOrderParams(orderID *big.Int) (struct{ ... }, error)

+ func (_Market *MarketSession) GetOrdersAmount() (*big.Int, error)

+ func (_Market *MarketSession) OpenDeal(_askID *big.Int, _bidID *big.Int) (*types.Transaction, error)

+ func (_Market *MarketSession) Orders(arg0 *big.Int) (struct{ ... }, error)

+ func (_Market *MarketSession) Owner() (common.Address, error)

+ func (_Market *MarketSession) Pause() (*types.Transaction, error)

+ func (_Market *MarketSession) Paused() (bool, error)

+ func (_Market *MarketSession) PlaceOrder(_orderType uint8, _id_counterparty common.Address, _duration *big.Int, ...) (*types.Transaction, error)

+ func (_Market *MarketSession) QuickBuy(askID *big.Int, buyoutDuration *big.Int) (*types.Transaction, error)

+ func (_Market *MarketSession) RegisterWorker(_master common.Address) (*types.Transaction, error)

+ func (_Market *MarketSession) RemoveWorker(_worker common.Address, _master common.Address) (*types.Transaction, error)

+ func (_Market *MarketSession) SetBenchmarksQuantity(_newQuantity *big.Int) (*types.Transaction, error)

+ func (_Market *MarketSession) SetBlacklistAddress(_newBL common.Address) (*types.Transaction, error)

+ func (_Market *MarketSession) SetNetflagsQuantity(_newQuantity *big.Int) (*types.Transaction, error)

+ func (_Market *MarketSession) SetOracleAddress(_newOracle common.Address) (*types.Transaction, error)

+ func (_Market *MarketSession) SetProfileRegistryAddress(_newPR common.Address) (*types.Transaction, error)

+ func (_Market *MarketSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_Market *MarketSession) Unpause() (*types.Transaction, error)

+ type MarketTransactor struct

+ func NewMarketTransactor(address common.Address, transactor bind.ContractTransactor) (*MarketTransactor, error)

+ func (_Market *MarketTransactor) Bill(opts *bind.TransactOpts, dealID *big.Int) (*types.Transaction, error)

+ func (_Market *MarketTransactor) CancelChangeRequest(opts *bind.TransactOpts, changeRequestID *big.Int) (*types.Transaction, error)

+ func (_Market *MarketTransactor) CancelOrder(opts *bind.TransactOpts, orderID *big.Int) (*types.Transaction, error)

+ func (_Market *MarketTransactor) CloseDeal(opts *bind.TransactOpts, dealID *big.Int, blacklisted uint8) (*types.Transaction, error)

+ func (_Market *MarketTransactor) ConfirmWorker(opts *bind.TransactOpts, _worker common.Address) (*types.Transaction, error)

+ func (_Market *MarketTransactor) CreateChangeRequest(opts *bind.TransactOpts, dealID *big.Int, newPrice *big.Int, ...) (*types.Transaction, error)

+ func (_Market *MarketTransactor) OpenDeal(opts *bind.TransactOpts, _askID *big.Int, _bidID *big.Int) (*types.Transaction, error)

+ func (_Market *MarketTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Market *MarketTransactor) PlaceOrder(opts *bind.TransactOpts, _orderType uint8, _id_counterparty common.Address, ...) (*types.Transaction, error)

+ func (_Market *MarketTransactor) QuickBuy(opts *bind.TransactOpts, askID *big.Int, buyoutDuration *big.Int) (*types.Transaction, error)

+ func (_Market *MarketTransactor) RegisterWorker(opts *bind.TransactOpts, _master common.Address) (*types.Transaction, error)

+ func (_Market *MarketTransactor) RemoveWorker(opts *bind.TransactOpts, _worker common.Address, _master common.Address) (*types.Transaction, error)

+ func (_Market *MarketTransactor) SetBenchmarksQuantity(opts *bind.TransactOpts, _newQuantity *big.Int) (*types.Transaction, error)

+ func (_Market *MarketTransactor) SetBlacklistAddress(opts *bind.TransactOpts, _newBL common.Address) (*types.Transaction, error)

+ func (_Market *MarketTransactor) SetNetflagsQuantity(opts *bind.TransactOpts, _newQuantity *big.Int) (*types.Transaction, error)

+ func (_Market *MarketTransactor) SetOracleAddress(opts *bind.TransactOpts, _newOracle common.Address) (*types.Transaction, error)

+ func (_Market *MarketTransactor) SetProfileRegistryAddress(opts *bind.TransactOpts, _newPR common.Address) (*types.Transaction, error)

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

+ func (_Market *MarketTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MarketTransactorRaw struct

+ Contract *MarketTransactor

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

+ func (_Market *MarketTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MarketTransactorSession struct

+ Contract *MarketTransactor

+ TransactOpts bind.TransactOpts

+ func (_Market *MarketTransactorSession) Bill(dealID *big.Int) (*types.Transaction, error)

+ func (_Market *MarketTransactorSession) CancelChangeRequest(changeRequestID *big.Int) (*types.Transaction, error)

+ func (_Market *MarketTransactorSession) CancelOrder(orderID *big.Int) (*types.Transaction, error)

+ func (_Market *MarketTransactorSession) CloseDeal(dealID *big.Int, blacklisted uint8) (*types.Transaction, error)

+ func (_Market *MarketTransactorSession) ConfirmWorker(_worker common.Address) (*types.Transaction, error)

+ func (_Market *MarketTransactorSession) CreateChangeRequest(dealID *big.Int, newPrice *big.Int, newDuration *big.Int) (*types.Transaction, error)

+ func (_Market *MarketTransactorSession) OpenDeal(_askID *big.Int, _bidID *big.Int) (*types.Transaction, error)

+ func (_Market *MarketTransactorSession) Pause() (*types.Transaction, error)

+ func (_Market *MarketTransactorSession) PlaceOrder(_orderType uint8, _id_counterparty common.Address, _duration *big.Int, ...) (*types.Transaction, error)

+ func (_Market *MarketTransactorSession) QuickBuy(askID *big.Int, buyoutDuration *big.Int) (*types.Transaction, error)

+ func (_Market *MarketTransactorSession) RegisterWorker(_master common.Address) (*types.Transaction, error)

+ func (_Market *MarketTransactorSession) RemoveWorker(_worker common.Address, _master common.Address) (*types.Transaction, error)

+ func (_Market *MarketTransactorSession) SetBenchmarksQuantity(_newQuantity *big.Int) (*types.Transaction, error)

+ func (_Market *MarketTransactorSession) SetBlacklistAddress(_newBL common.Address) (*types.Transaction, error)

+ func (_Market *MarketTransactorSession) SetNetflagsQuantity(_newQuantity *big.Int) (*types.Transaction, error)

+ func (_Market *MarketTransactorSession) SetOracleAddress(_newOracle common.Address) (*types.Transaction, error)

+ func (_Market *MarketTransactorSession) SetProfileRegistryAddress(_newPR common.Address) (*types.Transaction, error)

+ func (_Market *MarketTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_Market *MarketTransactorSession) Unpause() (*types.Transaction, error)

+ type MarketUnpause struct

+ Raw types.Log

+ type MarketUnpauseIterator struct

+ Event *MarketUnpause

+ func (it *MarketUnpauseIterator) Close() error

+ func (it *MarketUnpauseIterator) Error() error

+ func (it *MarketUnpauseIterator) Next() bool

+ type MarketWorkerAnnounced struct

+ Master common.Address

+ Raw types.Log

+ Worker common.Address

+ type MarketWorkerAnnouncedIterator struct

+ Event *MarketWorkerAnnounced

+ func (it *MarketWorkerAnnouncedIterator) Close() error

+ func (it *MarketWorkerAnnouncedIterator) Error() error

+ func (it *MarketWorkerAnnouncedIterator) Next() bool

+ type MarketWorkerConfirmed struct

+ Master common.Address

+ Raw types.Log

+ Worker common.Address

+ type MarketWorkerConfirmedIterator struct

+ Event *MarketWorkerConfirmed

+ func (it *MarketWorkerConfirmedIterator) Close() error

+ func (it *MarketWorkerConfirmedIterator) Error() error

+ func (it *MarketWorkerConfirmedIterator) Next() bool

+ type MarketWorkerRemoved struct

+ Master common.Address

+ Raw types.Log

+ Worker common.Address

+ type MarketWorkerRemovedIterator struct

+ Event *MarketWorkerRemoved

+ func (it *MarketWorkerRemovedIterator) Close() error

+ func (it *MarketWorkerRemovedIterator) Error() error

+ func (it *MarketWorkerRemovedIterator) Next() bool

+ type Migrations struct

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

+ func NewMigrations(address common.Address, backend bind.ContractBackend) (*Migrations, error)

+ type MigrationsCaller struct

+ func NewMigrationsCaller(address common.Address, caller bind.ContractCaller) (*MigrationsCaller, error)

+ func (_Migrations *MigrationsCaller) Last_completed_migration(opts *bind.CallOpts) (*big.Int, error)

+ func (_Migrations *MigrationsCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ type MigrationsCallerRaw struct

+ Contract *MigrationsCaller

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

+ type MigrationsCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *MigrationsCaller

+ func (_Migrations *MigrationsCallerSession) Last_completed_migration() (*big.Int, error)

+ func (_Migrations *MigrationsCallerSession) Owner() (common.Address, error)

+ type MigrationsFilterer struct

+ func NewMigrationsFilterer(address common.Address, filterer bind.ContractFilterer) (*MigrationsFilterer, error)

+ type MigrationsRaw struct

+ Contract *Migrations

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

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

+ func (_Migrations *MigrationsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MigrationsSession struct

+ CallOpts bind.CallOpts

+ Contract *Migrations

+ TransactOpts bind.TransactOpts

+ func (_Migrations *MigrationsSession) Last_completed_migration() (*big.Int, error)

+ func (_Migrations *MigrationsSession) Owner() (common.Address, error)

+ func (_Migrations *MigrationsSession) SetCompleted(completed *big.Int) (*types.Transaction, error)

+ func (_Migrations *MigrationsSession) Upgrade(new_address common.Address) (*types.Transaction, error)

+ type MigrationsTransactor struct

+ func NewMigrationsTransactor(address common.Address, transactor bind.ContractTransactor) (*MigrationsTransactor, error)

+ func (_Migrations *MigrationsTransactor) SetCompleted(opts *bind.TransactOpts, completed *big.Int) (*types.Transaction, error)

+ func (_Migrations *MigrationsTransactor) Upgrade(opts *bind.TransactOpts, new_address common.Address) (*types.Transaction, error)

+ type MigrationsTransactorRaw struct

+ Contract *MigrationsTransactor

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

+ func (_Migrations *MigrationsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MigrationsTransactorSession struct

+ Contract *MigrationsTransactor

+ TransactOpts bind.TransactOpts

+ func (_Migrations *MigrationsTransactorSession) SetCompleted(completed *big.Int) (*types.Transaction, error)

+ func (_Migrations *MigrationsTransactorSession) Upgrade(new_address common.Address) (*types.Transaction, error)

+ type MultiSigWallet struct

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

+ func NewMultiSigWallet(address common.Address, backend bind.ContractBackend) (*MultiSigWallet, error)

+ type MultiSigWalletCaller struct

+ func NewMultiSigWalletCaller(address common.Address, caller bind.ContractCaller) (*MultiSigWalletCaller, error)

+ func (_MultiSigWallet *MultiSigWalletCaller) Confirmations(opts *bind.CallOpts, arg0 *big.Int, arg1 common.Address) (bool, error)

+ func (_MultiSigWallet *MultiSigWalletCaller) GetConfirmationCount(opts *bind.CallOpts, transactionId *big.Int) (*big.Int, error)

+ func (_MultiSigWallet *MultiSigWalletCaller) GetConfirmations(opts *bind.CallOpts, transactionId *big.Int) ([]common.Address, error)

+ func (_MultiSigWallet *MultiSigWalletCaller) GetOwners(opts *bind.CallOpts) ([]common.Address, error)

+ func (_MultiSigWallet *MultiSigWalletCaller) GetTransactionCount(opts *bind.CallOpts, pending bool, executed bool) (*big.Int, error)

+ func (_MultiSigWallet *MultiSigWalletCaller) GetTransactionIds(opts *bind.CallOpts, from *big.Int, to *big.Int, pending bool, executed bool) ([]*big.Int, error)

+ func (_MultiSigWallet *MultiSigWalletCaller) IsConfirmed(opts *bind.CallOpts, transactionId *big.Int) (bool, error)

+ func (_MultiSigWallet *MultiSigWalletCaller) IsOwner(opts *bind.CallOpts, arg0 common.Address) (bool, error)

+ func (_MultiSigWallet *MultiSigWalletCaller) MAX_OWNER_COUNT(opts *bind.CallOpts) (*big.Int, error)

+ func (_MultiSigWallet *MultiSigWalletCaller) Owners(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error)

+ func (_MultiSigWallet *MultiSigWalletCaller) Required(opts *bind.CallOpts) (*big.Int, error)

+ func (_MultiSigWallet *MultiSigWalletCaller) TransactionCount(opts *bind.CallOpts) (*big.Int, error)

+ func (_MultiSigWallet *MultiSigWalletCaller) Transactions(opts *bind.CallOpts, arg0 *big.Int) (struct{ ... }, error)

+ type MultiSigWalletCallerRaw struct

+ Contract *MultiSigWalletCaller

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

+ type MultiSigWalletCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *MultiSigWalletCaller

+ func (_MultiSigWallet *MultiSigWalletCallerSession) Confirmations(arg0 *big.Int, arg1 common.Address) (bool, error)

+ func (_MultiSigWallet *MultiSigWalletCallerSession) GetConfirmationCount(transactionId *big.Int) (*big.Int, error)

+ func (_MultiSigWallet *MultiSigWalletCallerSession) GetConfirmations(transactionId *big.Int) ([]common.Address, error)

+ func (_MultiSigWallet *MultiSigWalletCallerSession) GetOwners() ([]common.Address, error)

+ func (_MultiSigWallet *MultiSigWalletCallerSession) GetTransactionCount(pending bool, executed bool) (*big.Int, error)

+ func (_MultiSigWallet *MultiSigWalletCallerSession) GetTransactionIds(from *big.Int, to *big.Int, pending bool, executed bool) ([]*big.Int, error)

+ func (_MultiSigWallet *MultiSigWalletCallerSession) IsConfirmed(transactionId *big.Int) (bool, error)

+ func (_MultiSigWallet *MultiSigWalletCallerSession) IsOwner(arg0 common.Address) (bool, error)

+ func (_MultiSigWallet *MultiSigWalletCallerSession) MAX_OWNER_COUNT() (*big.Int, error)

+ func (_MultiSigWallet *MultiSigWalletCallerSession) Owners(arg0 *big.Int) (common.Address, error)

+ func (_MultiSigWallet *MultiSigWalletCallerSession) Required() (*big.Int, error)

+ func (_MultiSigWallet *MultiSigWalletCallerSession) TransactionCount() (*big.Int, error)

+ func (_MultiSigWallet *MultiSigWalletCallerSession) Transactions(arg0 *big.Int) (struct{ ... }, error)

+ type MultiSigWalletConfirmation struct

+ Raw types.Log

+ Sender common.Address

+ TransactionId *big.Int

+ type MultiSigWalletConfirmationIterator struct

+ Event *MultiSigWalletConfirmation

+ func (it *MultiSigWalletConfirmationIterator) Close() error

+ func (it *MultiSigWalletConfirmationIterator) Error() error

+ func (it *MultiSigWalletConfirmationIterator) Next() bool

+ type MultiSigWalletDeposit struct

+ Raw types.Log

+ Sender common.Address

+ Value *big.Int

+ type MultiSigWalletDepositIterator struct

+ Event *MultiSigWalletDeposit

+ func (it *MultiSigWalletDepositIterator) Close() error

+ func (it *MultiSigWalletDepositIterator) Error() error

+ func (it *MultiSigWalletDepositIterator) Next() bool

+ type MultiSigWalletExecution struct

+ Raw types.Log

+ TransactionId *big.Int

+ type MultiSigWalletExecutionFailure struct

+ Raw types.Log

+ TransactionId *big.Int

+ type MultiSigWalletExecutionFailureIterator struct

+ Event *MultiSigWalletExecutionFailure

+ func (it *MultiSigWalletExecutionFailureIterator) Close() error

+ func (it *MultiSigWalletExecutionFailureIterator) Error() error

+ func (it *MultiSigWalletExecutionFailureIterator) Next() bool

+ type MultiSigWalletExecutionIterator struct

+ Event *MultiSigWalletExecution

+ func (it *MultiSigWalletExecutionIterator) Close() error

+ func (it *MultiSigWalletExecutionIterator) Error() error

+ func (it *MultiSigWalletExecutionIterator) Next() bool

+ type MultiSigWalletFilterer struct

+ func NewMultiSigWalletFilterer(address common.Address, filterer bind.ContractFilterer) (*MultiSigWalletFilterer, error)

+ func (_MultiSigWallet *MultiSigWalletFilterer) FilterConfirmation(opts *bind.FilterOpts, sender []common.Address, transactionId []*big.Int) (*MultiSigWalletConfirmationIterator, error)

+ func (_MultiSigWallet *MultiSigWalletFilterer) FilterDeposit(opts *bind.FilterOpts, sender []common.Address) (*MultiSigWalletDepositIterator, error)

+ func (_MultiSigWallet *MultiSigWalletFilterer) FilterExecution(opts *bind.FilterOpts, transactionId []*big.Int) (*MultiSigWalletExecutionIterator, error)

+ func (_MultiSigWallet *MultiSigWalletFilterer) FilterExecutionFailure(opts *bind.FilterOpts, transactionId []*big.Int) (*MultiSigWalletExecutionFailureIterator, error)

+ func (_MultiSigWallet *MultiSigWalletFilterer) FilterOwnerAddition(opts *bind.FilterOpts, owner []common.Address) (*MultiSigWalletOwnerAdditionIterator, error)

+ func (_MultiSigWallet *MultiSigWalletFilterer) FilterOwnerRemoval(opts *bind.FilterOpts, owner []common.Address) (*MultiSigWalletOwnerRemovalIterator, error)

+ func (_MultiSigWallet *MultiSigWalletFilterer) FilterRequirementChange(opts *bind.FilterOpts) (*MultiSigWalletRequirementChangeIterator, error)

+ func (_MultiSigWallet *MultiSigWalletFilterer) FilterRevocation(opts *bind.FilterOpts, sender []common.Address, transactionId []*big.Int) (*MultiSigWalletRevocationIterator, error)

+ func (_MultiSigWallet *MultiSigWalletFilterer) FilterSubmission(opts *bind.FilterOpts, transactionId []*big.Int) (*MultiSigWalletSubmissionIterator, error)

+ func (_MultiSigWallet *MultiSigWalletFilterer) WatchConfirmation(opts *bind.WatchOpts, sink chan<- *MultiSigWalletConfirmation, ...) (event.Subscription, error)

+ func (_MultiSigWallet *MultiSigWalletFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *MultiSigWalletDeposit, ...) (event.Subscription, error)

+ func (_MultiSigWallet *MultiSigWalletFilterer) WatchExecution(opts *bind.WatchOpts, sink chan<- *MultiSigWalletExecution, ...) (event.Subscription, error)

+ func (_MultiSigWallet *MultiSigWalletFilterer) WatchExecutionFailure(opts *bind.WatchOpts, sink chan<- *MultiSigWalletExecutionFailure, ...) (event.Subscription, error)

+ func (_MultiSigWallet *MultiSigWalletFilterer) WatchOwnerAddition(opts *bind.WatchOpts, sink chan<- *MultiSigWalletOwnerAddition, ...) (event.Subscription, error)

+ func (_MultiSigWallet *MultiSigWalletFilterer) WatchOwnerRemoval(opts *bind.WatchOpts, sink chan<- *MultiSigWalletOwnerRemoval, ...) (event.Subscription, error)

+ func (_MultiSigWallet *MultiSigWalletFilterer) WatchRequirementChange(opts *bind.WatchOpts, sink chan<- *MultiSigWalletRequirementChange) (event.Subscription, error)

+ func (_MultiSigWallet *MultiSigWalletFilterer) WatchRevocation(opts *bind.WatchOpts, sink chan<- *MultiSigWalletRevocation, ...) (event.Subscription, error)

+ func (_MultiSigWallet *MultiSigWalletFilterer) WatchSubmission(opts *bind.WatchOpts, sink chan<- *MultiSigWalletSubmission, ...) (event.Subscription, error)

+ type MultiSigWalletOwnerAddition struct

+ Owner common.Address

+ Raw types.Log

+ type MultiSigWalletOwnerAdditionIterator struct

+ Event *MultiSigWalletOwnerAddition

+ func (it *MultiSigWalletOwnerAdditionIterator) Close() error

+ func (it *MultiSigWalletOwnerAdditionIterator) Error() error

+ func (it *MultiSigWalletOwnerAdditionIterator) Next() bool

+ type MultiSigWalletOwnerRemoval struct

+ Owner common.Address

+ Raw types.Log

+ type MultiSigWalletOwnerRemovalIterator struct

+ Event *MultiSigWalletOwnerRemoval

+ func (it *MultiSigWalletOwnerRemovalIterator) Close() error

+ func (it *MultiSigWalletOwnerRemovalIterator) Error() error

+ func (it *MultiSigWalletOwnerRemovalIterator) Next() bool

+ type MultiSigWalletRaw struct

+ Contract *MultiSigWallet

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

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

+ func (_MultiSigWallet *MultiSigWalletRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MultiSigWalletRequirementChange struct

+ Raw types.Log

+ Required *big.Int

+ type MultiSigWalletRequirementChangeIterator struct

+ Event *MultiSigWalletRequirementChange

+ func (it *MultiSigWalletRequirementChangeIterator) Close() error

+ func (it *MultiSigWalletRequirementChangeIterator) Error() error

+ func (it *MultiSigWalletRequirementChangeIterator) Next() bool

+ type MultiSigWalletRevocation struct

+ Raw types.Log

+ Sender common.Address

+ TransactionId *big.Int

+ type MultiSigWalletRevocationIterator struct

+ Event *MultiSigWalletRevocation

+ func (it *MultiSigWalletRevocationIterator) Close() error

+ func (it *MultiSigWalletRevocationIterator) Error() error

+ func (it *MultiSigWalletRevocationIterator) Next() bool

+ type MultiSigWalletSession struct

+ CallOpts bind.CallOpts

+ Contract *MultiSigWallet

+ TransactOpts bind.TransactOpts

+ func (_MultiSigWallet *MultiSigWalletSession) AddOwner(owner common.Address) (*types.Transaction, error)

+ func (_MultiSigWallet *MultiSigWalletSession) ChangeRequirement(_required *big.Int) (*types.Transaction, error)

+ func (_MultiSigWallet *MultiSigWalletSession) ConfirmTransaction(transactionId *big.Int) (*types.Transaction, error)

+ func (_MultiSigWallet *MultiSigWalletSession) Confirmations(arg0 *big.Int, arg1 common.Address) (bool, error)

+ func (_MultiSigWallet *MultiSigWalletSession) ExecuteTransaction(transactionId *big.Int) (*types.Transaction, error)

+ func (_MultiSigWallet *MultiSigWalletSession) GetConfirmationCount(transactionId *big.Int) (*big.Int, error)

+ func (_MultiSigWallet *MultiSigWalletSession) GetConfirmations(transactionId *big.Int) ([]common.Address, error)

+ func (_MultiSigWallet *MultiSigWalletSession) GetOwners() ([]common.Address, error)

+ func (_MultiSigWallet *MultiSigWalletSession) GetTransactionCount(pending bool, executed bool) (*big.Int, error)

+ func (_MultiSigWallet *MultiSigWalletSession) GetTransactionIds(from *big.Int, to *big.Int, pending bool, executed bool) ([]*big.Int, error)

+ func (_MultiSigWallet *MultiSigWalletSession) IsConfirmed(transactionId *big.Int) (bool, error)

+ func (_MultiSigWallet *MultiSigWalletSession) IsOwner(arg0 common.Address) (bool, error)

+ func (_MultiSigWallet *MultiSigWalletSession) MAX_OWNER_COUNT() (*big.Int, error)

+ func (_MultiSigWallet *MultiSigWalletSession) Owners(arg0 *big.Int) (common.Address, error)

+ func (_MultiSigWallet *MultiSigWalletSession) RemoveOwner(owner common.Address) (*types.Transaction, error)

+ func (_MultiSigWallet *MultiSigWalletSession) ReplaceOwner(owner common.Address, newOwner common.Address) (*types.Transaction, error)

+ func (_MultiSigWallet *MultiSigWalletSession) Required() (*big.Int, error)

+ func (_MultiSigWallet *MultiSigWalletSession) RevokeConfirmation(transactionId *big.Int) (*types.Transaction, error)

+ func (_MultiSigWallet *MultiSigWalletSession) SubmitTransaction(destination common.Address, value *big.Int, data []byte) (*types.Transaction, error)

+ func (_MultiSigWallet *MultiSigWalletSession) TransactionCount() (*big.Int, error)

+ func (_MultiSigWallet *MultiSigWalletSession) Transactions(arg0 *big.Int) (struct{ ... }, error)

+ type MultiSigWalletSubmission struct

+ Raw types.Log

+ TransactionId *big.Int

+ type MultiSigWalletSubmissionIterator struct

+ Event *MultiSigWalletSubmission

+ func (it *MultiSigWalletSubmissionIterator) Close() error

+ func (it *MultiSigWalletSubmissionIterator) Error() error

+ func (it *MultiSigWalletSubmissionIterator) Next() bool

+ type MultiSigWalletTransactor struct

+ func NewMultiSigWalletTransactor(address common.Address, transactor bind.ContractTransactor) (*MultiSigWalletTransactor, error)

+ func (_MultiSigWallet *MultiSigWalletTransactor) AddOwner(opts *bind.TransactOpts, owner common.Address) (*types.Transaction, error)

+ func (_MultiSigWallet *MultiSigWalletTransactor) ChangeRequirement(opts *bind.TransactOpts, _required *big.Int) (*types.Transaction, error)

+ func (_MultiSigWallet *MultiSigWalletTransactor) ConfirmTransaction(opts *bind.TransactOpts, transactionId *big.Int) (*types.Transaction, error)

+ func (_MultiSigWallet *MultiSigWalletTransactor) ExecuteTransaction(opts *bind.TransactOpts, transactionId *big.Int) (*types.Transaction, error)

+ func (_MultiSigWallet *MultiSigWalletTransactor) RemoveOwner(opts *bind.TransactOpts, owner common.Address) (*types.Transaction, error)

+ func (_MultiSigWallet *MultiSigWalletTransactor) ReplaceOwner(opts *bind.TransactOpts, owner common.Address, newOwner common.Address) (*types.Transaction, error)

+ func (_MultiSigWallet *MultiSigWalletTransactor) RevokeConfirmation(opts *bind.TransactOpts, transactionId *big.Int) (*types.Transaction, error)

+ func (_MultiSigWallet *MultiSigWalletTransactor) SubmitTransaction(opts *bind.TransactOpts, destination common.Address, value *big.Int, ...) (*types.Transaction, error)

+ type MultiSigWalletTransactorRaw struct

+ Contract *MultiSigWalletTransactor

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

+ func (_MultiSigWallet *MultiSigWalletTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MultiSigWalletTransactorSession struct

+ Contract *MultiSigWalletTransactor

+ TransactOpts bind.TransactOpts

+ func (_MultiSigWallet *MultiSigWalletTransactorSession) AddOwner(owner common.Address) (*types.Transaction, error)

+ func (_MultiSigWallet *MultiSigWalletTransactorSession) ChangeRequirement(_required *big.Int) (*types.Transaction, error)

+ func (_MultiSigWallet *MultiSigWalletTransactorSession) ConfirmTransaction(transactionId *big.Int) (*types.Transaction, error)

+ func (_MultiSigWallet *MultiSigWalletTransactorSession) ExecuteTransaction(transactionId *big.Int) (*types.Transaction, error)

+ func (_MultiSigWallet *MultiSigWalletTransactorSession) RemoveOwner(owner common.Address) (*types.Transaction, error)

+ func (_MultiSigWallet *MultiSigWalletTransactorSession) ReplaceOwner(owner common.Address, newOwner common.Address) (*types.Transaction, error)

+ func (_MultiSigWallet *MultiSigWalletTransactorSession) RevokeConfirmation(transactionId *big.Int) (*types.Transaction, error)

+ func (_MultiSigWallet *MultiSigWalletTransactorSession) SubmitTransaction(destination common.Address, value *big.Int, data []byte) (*types.Transaction, error)

+ type OracleUSD struct

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

+ func NewOracleUSD(address common.Address, backend bind.ContractBackend) (*OracleUSD, error)

+ type OracleUSDCaller struct

+ func NewOracleUSDCaller(address common.Address, caller bind.ContractCaller) (*OracleUSDCaller, error)

+ func (_OracleUSD *OracleUSDCaller) GetCurrentPrice(opts *bind.CallOpts) (*big.Int, error)

+ func (_OracleUSD *OracleUSDCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ type OracleUSDCallerRaw struct

+ Contract *OracleUSDCaller

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

+ type OracleUSDCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OracleUSDCaller

+ func (_OracleUSD *OracleUSDCallerSession) GetCurrentPrice() (*big.Int, error)

+ func (_OracleUSD *OracleUSDCallerSession) Owner() (common.Address, error)

+ type OracleUSDFilterer struct

+ func NewOracleUSDFilterer(address common.Address, filterer bind.ContractFilterer) (*OracleUSDFilterer, error)

+ func (_OracleUSD *OracleUSDFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*OracleUSDOwnershipTransferredIterator, error)

+ func (_OracleUSD *OracleUSDFilterer) FilterPriceChanged(opts *bind.FilterOpts) (*OracleUSDPriceChangedIterator, error)

+ func (_OracleUSD *OracleUSDFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OracleUSDOwnershipTransferred, ...) (event.Subscription, error)

+ func (_OracleUSD *OracleUSDFilterer) WatchPriceChanged(opts *bind.WatchOpts, sink chan<- *OracleUSDPriceChanged) (event.Subscription, error)

+ type OracleUSDOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type OracleUSDOwnershipTransferredIterator struct

+ Event *OracleUSDOwnershipTransferred

+ func (it *OracleUSDOwnershipTransferredIterator) Close() error

+ func (it *OracleUSDOwnershipTransferredIterator) Error() error

+ func (it *OracleUSDOwnershipTransferredIterator) Next() bool

+ type OracleUSDPriceChanged struct

+ Price *big.Int

+ Raw types.Log

+ type OracleUSDPriceChangedIterator struct

+ Event *OracleUSDPriceChanged

+ func (it *OracleUSDPriceChangedIterator) Close() error

+ func (it *OracleUSDPriceChangedIterator) Error() error

+ func (it *OracleUSDPriceChangedIterator) Next() bool

+ type OracleUSDRaw struct

+ Contract *OracleUSD

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

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

+ func (_OracleUSD *OracleUSDRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OracleUSDSession struct

+ CallOpts bind.CallOpts

+ Contract *OracleUSD

+ TransactOpts bind.TransactOpts

+ func (_OracleUSD *OracleUSDSession) GetCurrentPrice() (*big.Int, error)

+ func (_OracleUSD *OracleUSDSession) Owner() (common.Address, error)

+ func (_OracleUSD *OracleUSDSession) SetCurrentPrice(_price *big.Int) (*types.Transaction, error)

+ func (_OracleUSD *OracleUSDSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type OracleUSDTransactor struct

+ func NewOracleUSDTransactor(address common.Address, transactor bind.ContractTransactor) (*OracleUSDTransactor, error)

+ func (_OracleUSD *OracleUSDTransactor) SetCurrentPrice(opts *bind.TransactOpts, _price *big.Int) (*types.Transaction, error)

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

+ type OracleUSDTransactorRaw struct

+ Contract *OracleUSDTransactor

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

+ func (_OracleUSD *OracleUSDTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OracleUSDTransactorSession struct

+ Contract *OracleUSDTransactor

+ TransactOpts bind.TransactOpts

+ func (_OracleUSD *OracleUSDTransactorSession) SetCurrentPrice(_price *big.Int) (*types.Transaction, error)

+ func (_OracleUSD *OracleUSDTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type Ownable struct

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

+ func NewOwnable(address common.Address, backend bind.ContractBackend) (*Ownable, error)

+ type OwnableCaller struct

+ func NewOwnableCaller(address common.Address, caller bind.ContractCaller) (*OwnableCaller, error)

+ func (_Ownable *OwnableCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ type OwnableCallerRaw struct

+ Contract *OwnableCaller

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

+ type OwnableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OwnableCaller

+ func (_Ownable *OwnableCallerSession) Owner() (common.Address, error)

+ type OwnableFilterer struct

+ func NewOwnableFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableFilterer, error)

+ func (_Ownable *OwnableFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*OwnableOwnershipTransferredIterator, error)

+ func (_Ownable *OwnableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OwnableOwnershipTransferred, ...) (event.Subscription, error)

+ type OwnableOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type OwnableOwnershipTransferredIterator struct

+ Event *OwnableOwnershipTransferred

+ func (it *OwnableOwnershipTransferredIterator) Close() error

+ func (it *OwnableOwnershipTransferredIterator) Error() error

+ func (it *OwnableOwnershipTransferredIterator) Next() bool

+ type OwnableRaw struct

+ Contract *Ownable

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

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

+ func (_Ownable *OwnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OwnableSession struct

+ CallOpts bind.CallOpts

+ Contract *Ownable

+ TransactOpts bind.TransactOpts

+ func (_Ownable *OwnableSession) Owner() (common.Address, error)

+ func (_Ownable *OwnableSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type OwnableTransactor struct

+ func NewOwnableTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableTransactor, error)

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

+ type OwnableTransactorRaw struct

+ Contract *OwnableTransactor

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

+ func (_Ownable *OwnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OwnableTransactorSession struct

+ Contract *OwnableTransactor

+ TransactOpts bind.TransactOpts

+ func (_Ownable *OwnableTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type Pausable struct

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

+ func NewPausable(address common.Address, backend bind.ContractBackend) (*Pausable, error)

+ type PausableCaller struct

+ func NewPausableCaller(address common.Address, caller bind.ContractCaller) (*PausableCaller, error)

+ func (_Pausable *PausableCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_Pausable *PausableCaller) Paused(opts *bind.CallOpts) (bool, error)

+ type PausableCallerRaw struct

+ Contract *PausableCaller

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

+ type PausableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *PausableCaller

+ func (_Pausable *PausableCallerSession) Owner() (common.Address, error)

+ func (_Pausable *PausableCallerSession) Paused() (bool, error)

+ type PausableFilterer struct

+ func NewPausableFilterer(address common.Address, filterer bind.ContractFilterer) (*PausableFilterer, error)

+ func (_Pausable *PausableFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*PausableOwnershipTransferredIterator, error)

+ func (_Pausable *PausableFilterer) FilterPause(opts *bind.FilterOpts) (*PausablePauseIterator, error)

+ func (_Pausable *PausableFilterer) FilterUnpause(opts *bind.FilterOpts) (*PausableUnpauseIterator, error)

+ func (_Pausable *PausableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *PausableOwnershipTransferred, ...) (event.Subscription, error)

+ func (_Pausable *PausableFilterer) WatchPause(opts *bind.WatchOpts, sink chan<- *PausablePause) (event.Subscription, error)

+ func (_Pausable *PausableFilterer) WatchUnpause(opts *bind.WatchOpts, sink chan<- *PausableUnpause) (event.Subscription, error)

+ type PausableOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type PausableOwnershipTransferredIterator struct

+ Event *PausableOwnershipTransferred

+ func (it *PausableOwnershipTransferredIterator) Close() error

+ func (it *PausableOwnershipTransferredIterator) Error() error

+ func (it *PausableOwnershipTransferredIterator) Next() bool

+ type PausablePause struct

+ Raw types.Log

+ type PausablePauseIterator struct

+ Event *PausablePause

+ func (it *PausablePauseIterator) Close() error

+ func (it *PausablePauseIterator) Error() error

+ func (it *PausablePauseIterator) Next() bool

+ type PausableRaw struct

+ Contract *Pausable

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

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

+ func (_Pausable *PausableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type PausableSession struct

+ CallOpts bind.CallOpts

+ Contract *Pausable

+ TransactOpts bind.TransactOpts

+ func (_Pausable *PausableSession) Owner() (common.Address, error)

+ func (_Pausable *PausableSession) Pause() (*types.Transaction, error)

+ func (_Pausable *PausableSession) Paused() (bool, error)

+ func (_Pausable *PausableSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_Pausable *PausableSession) Unpause() (*types.Transaction, error)

+ type PausableTransactor struct

+ func NewPausableTransactor(address common.Address, transactor bind.ContractTransactor) (*PausableTransactor, error)

+ func (_Pausable *PausableTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error)

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

+ func (_Pausable *PausableTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error)

+ type PausableTransactorRaw struct

+ Contract *PausableTransactor

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

+ func (_Pausable *PausableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type PausableTransactorSession struct

+ Contract *PausableTransactor

+ TransactOpts bind.TransactOpts

+ func (_Pausable *PausableTransactorSession) Pause() (*types.Transaction, error)

+ func (_Pausable *PausableTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_Pausable *PausableTransactorSession) Unpause() (*types.Transaction, error)

+ type PausableUnpause struct

+ Raw types.Log

+ type PausableUnpauseIterator struct

+ Event *PausableUnpause

+ func (it *PausableUnpauseIterator) Close() error

+ func (it *PausableUnpauseIterator) Error() error

+ func (it *PausableUnpauseIterator) Next() bool

+ type ProfileRegistry struct

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

+ func NewProfileRegistry(address common.Address, backend bind.ContractBackend) (*ProfileRegistry, error)

+ type ProfileRegistryCaller struct

+ func NewProfileRegistryCaller(address common.Address, caller bind.ContractCaller) (*ProfileRegistryCaller, error)

+ func (_ProfileRegistry *ProfileRegistryCaller) Certificates(opts *bind.CallOpts, arg0 *big.Int) (struct{ ... }, error)

+ func (_ProfileRegistry *ProfileRegistryCaller) GetAttributeCount(opts *bind.CallOpts, _owner common.Address, _type *big.Int) (*big.Int, error)

+ func (_ProfileRegistry *ProfileRegistryCaller) GetAttributeValue(opts *bind.CallOpts, _owner common.Address, _type *big.Int) ([]byte, error)

+ func (_ProfileRegistry *ProfileRegistryCaller) GetCertificate(opts *bind.CallOpts, _id *big.Int) (common.Address, common.Address, *big.Int, []byte, error)

+ func (_ProfileRegistry *ProfileRegistryCaller) GetProfileLevel(opts *bind.CallOpts, _owner common.Address) (uint8, error)

+ func (_ProfileRegistry *ProfileRegistryCaller) GetValidatorLevel(opts *bind.CallOpts, _validator common.Address) (int8, error)

+ func (_ProfileRegistry *ProfileRegistryCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_ProfileRegistry *ProfileRegistryCaller) Paused(opts *bind.CallOpts) (bool, error)

+ func (_ProfileRegistry *ProfileRegistryCaller) Validators(opts *bind.CallOpts, arg0 common.Address) (int8, error)

+ type ProfileRegistryCallerRaw struct

+ Contract *ProfileRegistryCaller

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

+ type ProfileRegistryCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ProfileRegistryCaller

+ func (_ProfileRegistry *ProfileRegistryCallerSession) Certificates(arg0 *big.Int) (struct{ ... }, error)

+ func (_ProfileRegistry *ProfileRegistryCallerSession) GetAttributeCount(_owner common.Address, _type *big.Int) (*big.Int, error)

+ func (_ProfileRegistry *ProfileRegistryCallerSession) GetAttributeValue(_owner common.Address, _type *big.Int) ([]byte, error)

+ func (_ProfileRegistry *ProfileRegistryCallerSession) GetCertificate(_id *big.Int) (common.Address, common.Address, *big.Int, []byte, error)

+ func (_ProfileRegistry *ProfileRegistryCallerSession) GetProfileLevel(_owner common.Address) (uint8, error)

+ func (_ProfileRegistry *ProfileRegistryCallerSession) GetValidatorLevel(_validator common.Address) (int8, error)

+ func (_ProfileRegistry *ProfileRegistryCallerSession) Owner() (common.Address, error)

+ func (_ProfileRegistry *ProfileRegistryCallerSession) Paused() (bool, error)

+ func (_ProfileRegistry *ProfileRegistryCallerSession) Validators(arg0 common.Address) (int8, error)

+ type ProfileRegistryCertificateCreated struct

+ Id *big.Int

+ Raw types.Log

+ type ProfileRegistryCertificateCreatedIterator struct

+ Event *ProfileRegistryCertificateCreated

+ func (it *ProfileRegistryCertificateCreatedIterator) Close() error

+ func (it *ProfileRegistryCertificateCreatedIterator) Error() error

+ func (it *ProfileRegistryCertificateCreatedIterator) Next() bool

+ type ProfileRegistryCertificateUpdated struct

+ Id *big.Int

+ Raw types.Log

+ type ProfileRegistryCertificateUpdatedIterator struct

+ Event *ProfileRegistryCertificateUpdated

+ func (it *ProfileRegistryCertificateUpdatedIterator) Close() error

+ func (it *ProfileRegistryCertificateUpdatedIterator) Error() error

+ func (it *ProfileRegistryCertificateUpdatedIterator) Next() bool

+ type ProfileRegistryFilterer struct

+ func NewProfileRegistryFilterer(address common.Address, filterer bind.ContractFilterer) (*ProfileRegistryFilterer, error)

+ func (_ProfileRegistry *ProfileRegistryFilterer) FilterCertificateCreated(opts *bind.FilterOpts, id []*big.Int) (*ProfileRegistryCertificateCreatedIterator, error)

+ func (_ProfileRegistry *ProfileRegistryFilterer) FilterCertificateUpdated(opts *bind.FilterOpts, id []*big.Int) (*ProfileRegistryCertificateUpdatedIterator, error)

+ func (_ProfileRegistry *ProfileRegistryFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*ProfileRegistryOwnershipTransferredIterator, error)

+ func (_ProfileRegistry *ProfileRegistryFilterer) FilterPause(opts *bind.FilterOpts) (*ProfileRegistryPauseIterator, error)

+ func (_ProfileRegistry *ProfileRegistryFilterer) FilterUnpause(opts *bind.FilterOpts) (*ProfileRegistryUnpauseIterator, error)

+ func (_ProfileRegistry *ProfileRegistryFilterer) FilterValidatorCreated(opts *bind.FilterOpts, validator []common.Address) (*ProfileRegistryValidatorCreatedIterator, error)

+ func (_ProfileRegistry *ProfileRegistryFilterer) FilterValidatorDeleted(opts *bind.FilterOpts, validator []common.Address) (*ProfileRegistryValidatorDeletedIterator, error)

+ func (_ProfileRegistry *ProfileRegistryFilterer) WatchCertificateCreated(opts *bind.WatchOpts, sink chan<- *ProfileRegistryCertificateCreated, ...) (event.Subscription, error)

+ func (_ProfileRegistry *ProfileRegistryFilterer) WatchCertificateUpdated(opts *bind.WatchOpts, sink chan<- *ProfileRegistryCertificateUpdated, ...) (event.Subscription, error)

+ func (_ProfileRegistry *ProfileRegistryFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *ProfileRegistryOwnershipTransferred, ...) (event.Subscription, error)

+ func (_ProfileRegistry *ProfileRegistryFilterer) WatchPause(opts *bind.WatchOpts, sink chan<- *ProfileRegistryPause) (event.Subscription, error)

+ func (_ProfileRegistry *ProfileRegistryFilterer) WatchUnpause(opts *bind.WatchOpts, sink chan<- *ProfileRegistryUnpause) (event.Subscription, error)

+ func (_ProfileRegistry *ProfileRegistryFilterer) WatchValidatorCreated(opts *bind.WatchOpts, sink chan<- *ProfileRegistryValidatorCreated, ...) (event.Subscription, error)

+ func (_ProfileRegistry *ProfileRegistryFilterer) WatchValidatorDeleted(opts *bind.WatchOpts, sink chan<- *ProfileRegistryValidatorDeleted, ...) (event.Subscription, error)

+ type ProfileRegistryOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type ProfileRegistryOwnershipTransferredIterator struct

+ Event *ProfileRegistryOwnershipTransferred

+ func (it *ProfileRegistryOwnershipTransferredIterator) Close() error

+ func (it *ProfileRegistryOwnershipTransferredIterator) Error() error

+ func (it *ProfileRegistryOwnershipTransferredIterator) Next() bool

+ type ProfileRegistryPause struct

+ Raw types.Log

+ type ProfileRegistryPauseIterator struct

+ Event *ProfileRegistryPause

+ func (it *ProfileRegistryPauseIterator) Close() error

+ func (it *ProfileRegistryPauseIterator) Error() error

+ func (it *ProfileRegistryPauseIterator) Next() bool

+ type ProfileRegistryRaw struct

+ Contract *ProfileRegistry

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

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

+ func (_ProfileRegistry *ProfileRegistryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ProfileRegistrySession struct

+ CallOpts bind.CallOpts

+ Contract *ProfileRegistry

+ TransactOpts bind.TransactOpts

+ func (_ProfileRegistry *ProfileRegistrySession) AddSonmValidator(_validator common.Address) (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistrySession) AddValidator(_validator common.Address, _level int8) (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistrySession) Certificates(arg0 *big.Int) (struct{ ... }, error)

+ func (_ProfileRegistry *ProfileRegistrySession) CreateCertificate(_owner common.Address, _type *big.Int, _value []byte) (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistrySession) GetAttributeCount(_owner common.Address, _type *big.Int) (*big.Int, error)

+ func (_ProfileRegistry *ProfileRegistrySession) GetAttributeValue(_owner common.Address, _type *big.Int) ([]byte, error)

+ func (_ProfileRegistry *ProfileRegistrySession) GetCertificate(_id *big.Int) (common.Address, common.Address, *big.Int, []byte, error)

+ func (_ProfileRegistry *ProfileRegistrySession) GetProfileLevel(_owner common.Address) (uint8, error)

+ func (_ProfileRegistry *ProfileRegistrySession) GetValidatorLevel(_validator common.Address) (int8, error)

+ func (_ProfileRegistry *ProfileRegistrySession) Owner() (common.Address, error)

+ func (_ProfileRegistry *ProfileRegistrySession) Pause() (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistrySession) Paused() (bool, error)

+ func (_ProfileRegistry *ProfileRegistrySession) RemoveCertificate(_id *big.Int) (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistrySession) RemoveSonmValidator(_validator common.Address) (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistrySession) RemoveValidator(_validator common.Address) (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistrySession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistrySession) Unpause() (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistrySession) Validators(arg0 common.Address) (int8, error)

+ type ProfileRegistryTransactor struct

+ func NewProfileRegistryTransactor(address common.Address, transactor bind.ContractTransactor) (*ProfileRegistryTransactor, error)

+ func (_ProfileRegistry *ProfileRegistryTransactor) AddSonmValidator(opts *bind.TransactOpts, _validator common.Address) (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistryTransactor) AddValidator(opts *bind.TransactOpts, _validator common.Address, _level int8) (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistryTransactor) CreateCertificate(opts *bind.TransactOpts, _owner common.Address, _type *big.Int, _value []byte) (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistryTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistryTransactor) RemoveCertificate(opts *bind.TransactOpts, _id *big.Int) (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistryTransactor) RemoveSonmValidator(opts *bind.TransactOpts, _validator common.Address) (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistryTransactor) RemoveValidator(opts *bind.TransactOpts, _validator common.Address) (*types.Transaction, error)

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

+ func (_ProfileRegistry *ProfileRegistryTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ProfileRegistryTransactorRaw struct

+ Contract *ProfileRegistryTransactor

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

+ func (_ProfileRegistry *ProfileRegistryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ProfileRegistryTransactorSession struct

+ Contract *ProfileRegistryTransactor

+ TransactOpts bind.TransactOpts

+ func (_ProfileRegistry *ProfileRegistryTransactorSession) AddSonmValidator(_validator common.Address) (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistryTransactorSession) AddValidator(_validator common.Address, _level int8) (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistryTransactorSession) CreateCertificate(_owner common.Address, _type *big.Int, _value []byte) (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistryTransactorSession) Pause() (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistryTransactorSession) RemoveCertificate(_id *big.Int) (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistryTransactorSession) RemoveSonmValidator(_validator common.Address) (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistryTransactorSession) RemoveValidator(_validator common.Address) (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistryTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_ProfileRegistry *ProfileRegistryTransactorSession) Unpause() (*types.Transaction, error)

+ type ProfileRegistryUnpause struct

+ Raw types.Log

+ type ProfileRegistryUnpauseIterator struct

+ Event *ProfileRegistryUnpause

+ func (it *ProfileRegistryUnpauseIterator) Close() error

+ func (it *ProfileRegistryUnpauseIterator) Error() error

+ func (it *ProfileRegistryUnpauseIterator) Next() bool

+ type ProfileRegistryValidatorCreated struct

+ Raw types.Log

+ Validator common.Address

+ type ProfileRegistryValidatorCreatedIterator struct

+ Event *ProfileRegistryValidatorCreated

+ func (it *ProfileRegistryValidatorCreatedIterator) Close() error

+ func (it *ProfileRegistryValidatorCreatedIterator) Error() error

+ func (it *ProfileRegistryValidatorCreatedIterator) Next() bool

+ type ProfileRegistryValidatorDeleted struct

+ Raw types.Log

+ Validator common.Address

+ type ProfileRegistryValidatorDeletedIterator struct

+ Event *ProfileRegistryValidatorDeleted

+ func (it *ProfileRegistryValidatorDeletedIterator) Close() error

+ func (it *ProfileRegistryValidatorDeletedIterator) Error() error

+ func (it *ProfileRegistryValidatorDeletedIterator) Next() bool

+ type SNM struct

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

+ func NewSNM(address common.Address, backend bind.ContractBackend) (*SNM, error)

+ type SNMApproval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type SNMApprovalIterator struct

+ Event *SNMApproval

+ func (it *SNMApprovalIterator) Close() error

+ func (it *SNMApprovalIterator) Error() error

+ func (it *SNMApprovalIterator) Next() bool

+ type SNMCaller struct

+ func NewSNMCaller(address common.Address, caller bind.ContractCaller) (*SNMCaller, error)

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

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

+ func (_SNM *SNMCaller) Decimals(opts *bind.CallOpts) (*big.Int, error)

+ func (_SNM *SNMCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_SNM *SNMCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_SNM *SNMCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_SNM *SNMCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type SNMCallerRaw struct

+ Contract *SNMCaller

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

+ type SNMCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SNMCaller

+ func (_SNM *SNMCallerSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error)

+ func (_SNM *SNMCallerSession) BalanceOf(_owner common.Address) (*big.Int, error)

+ func (_SNM *SNMCallerSession) Decimals() (*big.Int, error)

+ func (_SNM *SNMCallerSession) Name() (string, error)

+ func (_SNM *SNMCallerSession) Owner() (common.Address, error)

+ func (_SNM *SNMCallerSession) Symbol() (string, error)

+ func (_SNM *SNMCallerSession) TotalSupply() (*big.Int, error)

+ type SNMD struct

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

+ func NewSNMD(address common.Address, backend bind.ContractBackend) (*SNMD, error)

+ type SNMDApproval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type SNMDApprovalIterator struct

+ Event *SNMDApproval

+ func (it *SNMDApprovalIterator) Close() error

+ func (it *SNMDApprovalIterator) Error() error

+ func (it *SNMDApprovalIterator) Next() bool

+ type SNMDCaller struct

+ func NewSNMDCaller(address common.Address, caller bind.ContractCaller) (*SNMDCaller, error)

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

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

+ func (_SNMD *SNMDCaller) Decimals(opts *bind.CallOpts) (*big.Int, error)

+ func (_SNMD *SNMDCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_SNMD *SNMDCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_SNMD *SNMDCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_SNMD *SNMDCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type SNMDCallerRaw struct

+ Contract *SNMDCaller

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

+ type SNMDCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SNMDCaller

+ func (_SNMD *SNMDCallerSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error)

+ func (_SNMD *SNMDCallerSession) BalanceOf(_owner common.Address) (*big.Int, error)

+ func (_SNMD *SNMDCallerSession) Decimals() (*big.Int, error)

+ func (_SNMD *SNMDCallerSession) Name() (string, error)

+ func (_SNMD *SNMDCallerSession) Owner() (common.Address, error)

+ func (_SNMD *SNMDCallerSession) Symbol() (string, error)

+ func (_SNMD *SNMDCallerSession) TotalSupply() (*big.Int, error)

+ type SNMDFilterer struct

+ func NewSNMDFilterer(address common.Address, filterer bind.ContractFilterer) (*SNMDFilterer, error)

+ func (_SNMD *SNMDFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*SNMDApprovalIterator, error)

+ func (_SNMD *SNMDFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*SNMDOwnershipTransferredIterator, error)

+ func (_SNMD *SNMDFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*SNMDTransferIterator, error)

+ func (_SNMD *SNMDFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *SNMDApproval, owner []common.Address, ...) (event.Subscription, error)

+ func (_SNMD *SNMDFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *SNMDOwnershipTransferred, ...) (event.Subscription, error)

+ func (_SNMD *SNMDFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *SNMDTransfer, from []common.Address, ...) (event.Subscription, error)

+ type SNMDOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type SNMDOwnershipTransferredIterator struct

+ Event *SNMDOwnershipTransferred

+ func (it *SNMDOwnershipTransferredIterator) Close() error

+ func (it *SNMDOwnershipTransferredIterator) Error() error

+ func (it *SNMDOwnershipTransferredIterator) Next() bool

+ type SNMDRaw struct

+ Contract *SNMD

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

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

+ func (_SNMD *SNMDRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SNMDSession struct

+ CallOpts bind.CallOpts

+ Contract *SNMD

+ TransactOpts bind.TransactOpts

+ func (_SNMD *SNMDSession) AddMarket(_newMarket common.Address) (*types.Transaction, error)

+ func (_SNMD *SNMDSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error)

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

+ func (_SNMD *SNMDSession) BalanceOf(_owner common.Address) (*big.Int, error)

+ func (_SNMD *SNMDSession) Decimals() (*big.Int, error)

+ func (_SNMD *SNMDSession) DecreaseApproval(_spender common.Address, _subtractedValue *big.Int) (*types.Transaction, error)

+ func (_SNMD *SNMDSession) IncreaseApproval(_spender common.Address, _addedValue *big.Int) (*types.Transaction, error)

+ func (_SNMD *SNMDSession) Name() (string, error)

+ func (_SNMD *SNMDSession) Owner() (common.Address, error)

+ func (_SNMD *SNMDSession) Symbol() (string, error)

+ func (_SNMD *SNMDSession) TotalSupply() (*big.Int, error)

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

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

+ func (_SNMD *SNMDSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type SNMDTransactor struct

+ func NewSNMDTransactor(address common.Address, transactor bind.ContractTransactor) (*SNMDTransactor, error)

+ func (_SNMD *SNMDTransactor) AddMarket(opts *bind.TransactOpts, _newMarket common.Address) (*types.Transaction, error)

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

+ func (_SNMD *SNMDTransactor) DecreaseApproval(opts *bind.TransactOpts, _spender common.Address, _subtractedValue *big.Int) (*types.Transaction, error)

+ func (_SNMD *SNMDTransactor) IncreaseApproval(opts *bind.TransactOpts, _spender common.Address, _addedValue *big.Int) (*types.Transaction, error)

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

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

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

+ type SNMDTransactorRaw struct

+ Contract *SNMDTransactor

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

+ func (_SNMD *SNMDTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SNMDTransactorSession struct

+ Contract *SNMDTransactor

+ TransactOpts bind.TransactOpts

+ func (_SNMD *SNMDTransactorSession) AddMarket(_newMarket common.Address) (*types.Transaction, error)

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

+ func (_SNMD *SNMDTransactorSession) DecreaseApproval(_spender common.Address, _subtractedValue *big.Int) (*types.Transaction, error)

+ func (_SNMD *SNMDTransactorSession) IncreaseApproval(_spender common.Address, _addedValue *big.Int) (*types.Transaction, error)

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

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

+ func (_SNMD *SNMDTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type SNMDTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type SNMDTransferIterator struct

+ Event *SNMDTransfer

+ func (it *SNMDTransferIterator) Close() error

+ func (it *SNMDTransferIterator) Error() error

+ func (it *SNMDTransferIterator) Next() bool

+ type SNMFilterer struct

+ func NewSNMFilterer(address common.Address, filterer bind.ContractFilterer) (*SNMFilterer, error)

+ func (_SNM *SNMFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*SNMApprovalIterator, error)

+ func (_SNM *SNMFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*SNMOwnershipTransferredIterator, error)

+ func (_SNM *SNMFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*SNMTransferIterator, error)

+ func (_SNM *SNMFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *SNMApproval, owner []common.Address, ...) (event.Subscription, error)

+ func (_SNM *SNMFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *SNMOwnershipTransferred, ...) (event.Subscription, error)

+ func (_SNM *SNMFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *SNMTransfer, from []common.Address, ...) (event.Subscription, error)

+ type SNMMasterchain struct

+ func DeploySNMMasterchain(auth *bind.TransactOpts, backend bind.ContractBackend, _ico common.Address) (common.Address, *types.Transaction, *SNMMasterchain, error)

+ func NewSNMMasterchain(address common.Address, backend bind.ContractBackend) (*SNMMasterchain, error)

+ type SNMMasterchainApproval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type SNMMasterchainApprovalIterator struct

+ Event *SNMMasterchainApproval

+ func (it *SNMMasterchainApprovalIterator) Close() error

+ func (it *SNMMasterchainApprovalIterator) Error() error

+ func (it *SNMMasterchainApprovalIterator) Next() bool

+ type SNMMasterchainCaller struct

+ func NewSNMMasterchainCaller(address common.Address, caller bind.ContractCaller) (*SNMMasterchainCaller, error)

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

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

+ func (_SNMMasterchain *SNMMasterchainCaller) Decimals(opts *bind.CallOpts) (*big.Int, error)

+ func (_SNMMasterchain *SNMMasterchainCaller) Ico(opts *bind.CallOpts) (common.Address, error)

+ func (_SNMMasterchain *SNMMasterchainCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_SNMMasterchain *SNMMasterchainCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_SNMMasterchain *SNMMasterchainCaller) TokensAreFrozen(opts *bind.CallOpts) (bool, error)

+ func (_SNMMasterchain *SNMMasterchainCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type SNMMasterchainCallerRaw struct

+ Contract *SNMMasterchainCaller

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

+ type SNMMasterchainCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SNMMasterchainCaller

+ func (_SNMMasterchain *SNMMasterchainCallerSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error)

+ func (_SNMMasterchain *SNMMasterchainCallerSession) BalanceOf(_owner common.Address) (*big.Int, error)

+ func (_SNMMasterchain *SNMMasterchainCallerSession) Decimals() (*big.Int, error)

+ func (_SNMMasterchain *SNMMasterchainCallerSession) Ico() (common.Address, error)

+ func (_SNMMasterchain *SNMMasterchainCallerSession) Name() (string, error)

+ func (_SNMMasterchain *SNMMasterchainCallerSession) Symbol() (string, error)

+ func (_SNMMasterchain *SNMMasterchainCallerSession) TokensAreFrozen() (bool, error)

+ func (_SNMMasterchain *SNMMasterchainCallerSession) TotalSupply() (*big.Int, error)

+ type SNMMasterchainFilterer struct

+ func NewSNMMasterchainFilterer(address common.Address, filterer bind.ContractFilterer) (*SNMMasterchainFilterer, error)

+ func (_SNMMasterchain *SNMMasterchainFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*SNMMasterchainApprovalIterator, error)

+ func (_SNMMasterchain *SNMMasterchainFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*SNMMasterchainTransferIterator, error)

+ func (_SNMMasterchain *SNMMasterchainFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *SNMMasterchainApproval, ...) (event.Subscription, error)

+ func (_SNMMasterchain *SNMMasterchainFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *SNMMasterchainTransfer, ...) (event.Subscription, error)

+ type SNMMasterchainRaw struct

+ Contract *SNMMasterchain

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

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

+ func (_SNMMasterchain *SNMMasterchainRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SNMMasterchainSession struct

+ CallOpts bind.CallOpts

+ Contract *SNMMasterchain

+ TransactOpts bind.TransactOpts

+ func (_SNMMasterchain *SNMMasterchainSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error)

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

+ func (_SNMMasterchain *SNMMasterchainSession) BalanceOf(_owner common.Address) (*big.Int, error)

+ func (_SNMMasterchain *SNMMasterchainSession) Decimals() (*big.Int, error)

+ func (_SNMMasterchain *SNMMasterchainSession) Defrost() (*types.Transaction, error)

+ func (_SNMMasterchain *SNMMasterchainSession) Ico() (common.Address, error)

+ func (_SNMMasterchain *SNMMasterchainSession) Mint(_holder common.Address, _value *big.Int) (*types.Transaction, error)

+ func (_SNMMasterchain *SNMMasterchainSession) Name() (string, error)

+ func (_SNMMasterchain *SNMMasterchainSession) Symbol() (string, error)

+ func (_SNMMasterchain *SNMMasterchainSession) TokensAreFrozen() (bool, error)

+ func (_SNMMasterchain *SNMMasterchainSession) TotalSupply() (*big.Int, error)

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

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

+ type SNMMasterchainTransactor struct

+ func NewSNMMasterchainTransactor(address common.Address, transactor bind.ContractTransactor) (*SNMMasterchainTransactor, error)

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

+ func (_SNMMasterchain *SNMMasterchainTransactor) Defrost(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_SNMMasterchain *SNMMasterchainTransactor) Mint(opts *bind.TransactOpts, _holder common.Address, _value *big.Int) (*types.Transaction, error)

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

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

+ type SNMMasterchainTransactorRaw struct

+ Contract *SNMMasterchainTransactor

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

+ func (_SNMMasterchain *SNMMasterchainTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SNMMasterchainTransactorSession struct

+ Contract *SNMMasterchainTransactor

+ TransactOpts bind.TransactOpts

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

+ func (_SNMMasterchain *SNMMasterchainTransactorSession) Defrost() (*types.Transaction, error)

+ func (_SNMMasterchain *SNMMasterchainTransactorSession) Mint(_holder common.Address, _value *big.Int) (*types.Transaction, error)

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

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

+ type SNMMasterchainTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type SNMMasterchainTransferIterator struct

+ Event *SNMMasterchainTransfer

+ func (it *SNMMasterchainTransferIterator) Close() error

+ func (it *SNMMasterchainTransferIterator) Error() error

+ func (it *SNMMasterchainTransferIterator) Next() bool

+ type SNMOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type SNMOwnershipTransferredIterator struct

+ Event *SNMOwnershipTransferred

+ func (it *SNMOwnershipTransferredIterator) Close() error

+ func (it *SNMOwnershipTransferredIterator) Error() error

+ func (it *SNMOwnershipTransferredIterator) Next() bool

+ type SNMRaw struct

+ Contract *SNM

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

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

+ func (_SNM *SNMRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SNMSession struct

+ CallOpts bind.CallOpts

+ Contract *SNM

+ TransactOpts bind.TransactOpts

+ func (_SNM *SNMSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error)

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

+ func (_SNM *SNMSession) BalanceOf(_owner common.Address) (*big.Int, error)

+ func (_SNM *SNMSession) Decimals() (*big.Int, error)

+ func (_SNM *SNMSession) DecreaseApproval(_spender common.Address, _subtractedValue *big.Int) (*types.Transaction, error)

+ func (_SNM *SNMSession) IncreaseApproval(_spender common.Address, _addedValue *big.Int) (*types.Transaction, error)

+ func (_SNM *SNMSession) Name() (string, error)

+ func (_SNM *SNMSession) Owner() (common.Address, error)

+ func (_SNM *SNMSession) Symbol() (string, error)

+ func (_SNM *SNMSession) TotalSupply() (*big.Int, error)

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

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

+ func (_SNM *SNMSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type SNMTToken struct

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

+ func NewSNMTToken(address common.Address, backend bind.ContractBackend) (*SNMTToken, error)

+ type SNMTTokenApproval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type SNMTTokenApprovalIterator struct

+ Event *SNMTTokenApproval

+ func (it *SNMTTokenApprovalIterator) Close() error

+ func (it *SNMTTokenApprovalIterator) Error() error

+ func (it *SNMTTokenApprovalIterator) Next() bool

+ type SNMTTokenCaller struct

+ func NewSNMTTokenCaller(address common.Address, caller bind.ContractCaller) (*SNMTTokenCaller, error)

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

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

+ func (_SNMTToken *SNMTTokenCaller) Decimals(opts *bind.CallOpts) (*big.Int, error)

+ func (_SNMTToken *SNMTTokenCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_SNMTToken *SNMTTokenCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_SNMTToken *SNMTTokenCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_SNMTToken *SNMTTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type SNMTTokenCallerRaw struct

+ Contract *SNMTTokenCaller

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

+ type SNMTTokenCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SNMTTokenCaller

+ func (_SNMTToken *SNMTTokenCallerSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error)

+ func (_SNMTToken *SNMTTokenCallerSession) BalanceOf(_owner common.Address) (*big.Int, error)

+ func (_SNMTToken *SNMTTokenCallerSession) Decimals() (*big.Int, error)

+ func (_SNMTToken *SNMTTokenCallerSession) Name() (string, error)

+ func (_SNMTToken *SNMTTokenCallerSession) Owner() (common.Address, error)

+ func (_SNMTToken *SNMTTokenCallerSession) Symbol() (string, error)

+ func (_SNMTToken *SNMTTokenCallerSession) TotalSupply() (*big.Int, error)

+ type SNMTTokenFilterer struct

+ func NewSNMTTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*SNMTTokenFilterer, error)

+ func (_SNMTToken *SNMTTokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*SNMTTokenApprovalIterator, error)

+ func (_SNMTToken *SNMTTokenFilterer) FilterGiveAway(opts *bind.FilterOpts) (*SNMTTokenGiveAwayIterator, error)

+ func (_SNMTToken *SNMTTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*SNMTTokenTransferIterator, error)

+ func (_SNMTToken *SNMTTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *SNMTTokenApproval, owner []common.Address, ...) (event.Subscription, error)

+ func (_SNMTToken *SNMTTokenFilterer) WatchGiveAway(opts *bind.WatchOpts, sink chan<- *SNMTTokenGiveAway) (event.Subscription, error)

+ func (_SNMTToken *SNMTTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *SNMTTokenTransfer, from []common.Address, ...) (event.Subscription, error)

+ type SNMTTokenGiveAway struct

+ Amount *big.Int

+ Raw types.Log

+ Whom common.Address

+ type SNMTTokenGiveAwayIterator struct

+ Event *SNMTTokenGiveAway

+ func (it *SNMTTokenGiveAwayIterator) Close() error

+ func (it *SNMTTokenGiveAwayIterator) Error() error

+ func (it *SNMTTokenGiveAwayIterator) Next() bool

+ type SNMTTokenRaw struct

+ Contract *SNMTToken

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

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

+ func (_SNMTToken *SNMTTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SNMTTokenSession struct

+ CallOpts bind.CallOpts

+ Contract *SNMTToken

+ TransactOpts bind.TransactOpts

+ func (_SNMTToken *SNMTTokenSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error)

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

+ func (_SNMTToken *SNMTTokenSession) BalanceOf(_owner common.Address) (*big.Int, error)

+ func (_SNMTToken *SNMTTokenSession) Decimals() (*big.Int, error)

+ func (_SNMTToken *SNMTTokenSession) GetTokens() (*types.Transaction, error)

+ func (_SNMTToken *SNMTTokenSession) MintToken(target common.Address, mintedAmount *big.Int) (*types.Transaction, error)

+ func (_SNMTToken *SNMTTokenSession) Name() (string, error)

+ func (_SNMTToken *SNMTTokenSession) Owner() (common.Address, error)

+ func (_SNMTToken *SNMTTokenSession) Symbol() (string, error)

+ func (_SNMTToken *SNMTTokenSession) TotalSupply() (*big.Int, error)

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

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

+ func (_SNMTToken *SNMTTokenSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type SNMTTokenTransactor struct

+ func NewSNMTTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*SNMTTokenTransactor, error)

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

+ func (_SNMTToken *SNMTTokenTransactor) GetTokens(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_SNMTToken *SNMTTokenTransactor) MintToken(opts *bind.TransactOpts, target common.Address, mintedAmount *big.Int) (*types.Transaction, error)

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

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

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

+ type SNMTTokenTransactorRaw struct

+ Contract *SNMTTokenTransactor

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

+ func (_SNMTToken *SNMTTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SNMTTokenTransactorSession struct

+ Contract *SNMTTokenTransactor

+ TransactOpts bind.TransactOpts

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

+ func (_SNMTToken *SNMTTokenTransactorSession) GetTokens() (*types.Transaction, error)

+ func (_SNMTToken *SNMTTokenTransactorSession) MintToken(target common.Address, mintedAmount *big.Int) (*types.Transaction, error)

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

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

+ func (_SNMTToken *SNMTTokenTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type SNMTTokenTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type SNMTTokenTransferIterator struct

+ Event *SNMTTokenTransfer

+ func (it *SNMTTokenTransferIterator) Close() error

+ func (it *SNMTTokenTransferIterator) Error() error

+ func (it *SNMTTokenTransferIterator) Next() bool

+ type SNMTransactor struct

+ func NewSNMTransactor(address common.Address, transactor bind.ContractTransactor) (*SNMTransactor, error)

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

+ func (_SNM *SNMTransactor) DecreaseApproval(opts *bind.TransactOpts, _spender common.Address, _subtractedValue *big.Int) (*types.Transaction, error)

+ func (_SNM *SNMTransactor) IncreaseApproval(opts *bind.TransactOpts, _spender common.Address, _addedValue *big.Int) (*types.Transaction, error)

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

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

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

+ type SNMTransactorRaw struct

+ Contract *SNMTransactor

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

+ func (_SNM *SNMTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SNMTransactorSession struct

+ Contract *SNMTransactor

+ TransactOpts bind.TransactOpts

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

+ func (_SNM *SNMTransactorSession) DecreaseApproval(_spender common.Address, _subtractedValue *big.Int) (*types.Transaction, error)

+ func (_SNM *SNMTransactorSession) IncreaseApproval(_spender common.Address, _addedValue *big.Int) (*types.Transaction, error)

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

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

+ func (_SNM *SNMTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type SNMTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type SNMTransferIterator struct

+ Event *SNMTransfer

+ func (it *SNMTransferIterator) Close() error

+ func (it *SNMTransferIterator) Error() error

+ func (it *SNMTransferIterator) Next() bool

+ type SafeMath struct

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

+ func NewSafeMath(address common.Address, backend bind.ContractBackend) (*SafeMath, error)

+ type SafeMathCaller struct

+ func NewSafeMathCaller(address common.Address, caller bind.ContractCaller) (*SafeMathCaller, error)

+ type SafeMathCallerRaw struct

+ Contract *SafeMathCaller

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

+ type SafeMathCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SafeMathCaller

+ type SafeMathFilterer struct

+ func NewSafeMathFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeMathFilterer, error)

+ type SafeMathRaw struct

+ Contract *SafeMath

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

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

+ func (_SafeMath *SafeMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeMathSession struct

+ CallOpts bind.CallOpts

+ Contract *SafeMath

+ TransactOpts bind.TransactOpts

+ type SafeMathTransactor struct

+ func NewSafeMathTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeMathTransactor, error)

+ type SafeMathTransactorRaw struct

+ Contract *SafeMathTransactor

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

+ func (_SafeMath *SafeMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeMathTransactorSession struct

+ Contract *SafeMathTransactor

+ TransactOpts bind.TransactOpts

+ type SimpleGatekeeper struct

+ func DeploySimpleGatekeeper(auth *bind.TransactOpts, backend bind.ContractBackend, _token common.Address) (common.Address, *types.Transaction, *SimpleGatekeeper, error)

+ func NewSimpleGatekeeper(address common.Address, backend bind.ContractBackend) (*SimpleGatekeeper, error)

+ type SimpleGatekeeperCaller struct

+ func NewSimpleGatekeeperCaller(address common.Address, caller bind.ContractCaller) (*SimpleGatekeeperCaller, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperCaller) Paid(opts *bind.CallOpts, arg0 [32]byte) (bool, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperCaller) TransactionAmount(opts *bind.CallOpts) (*big.Int, error)

+ type SimpleGatekeeperCallerRaw struct

+ Contract *SimpleGatekeeperCaller

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

+ type SimpleGatekeeperCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SimpleGatekeeperCaller

+ func (_SimpleGatekeeper *SimpleGatekeeperCallerSession) Owner() (common.Address, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperCallerSession) Paid(arg0 [32]byte) (bool, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperCallerSession) TransactionAmount() (*big.Int, error)

+ type SimpleGatekeeperFilterer struct

+ func NewSimpleGatekeeperFilterer(address common.Address, filterer bind.ContractFilterer) (*SimpleGatekeeperFilterer, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*SimpleGatekeeperOwnershipTransferredIterator, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperFilterer) FilterPayInTx(opts *bind.FilterOpts, from []common.Address, txNumber []*big.Int, ...) (*SimpleGatekeeperPayInTxIterator, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperFilterer) FilterPayoutTx(opts *bind.FilterOpts, from []common.Address, txNumber []*big.Int, ...) (*SimpleGatekeeperPayoutTxIterator, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperFilterer) FilterSuicide(opts *bind.FilterOpts) (*SimpleGatekeeperSuicideIterator, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *SimpleGatekeeperOwnershipTransferred, ...) (event.Subscription, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperFilterer) WatchPayInTx(opts *bind.WatchOpts, sink chan<- *SimpleGatekeeperPayInTx, ...) (event.Subscription, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperFilterer) WatchPayoutTx(opts *bind.WatchOpts, sink chan<- *SimpleGatekeeperPayoutTx, ...) (event.Subscription, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperFilterer) WatchSuicide(opts *bind.WatchOpts, sink chan<- *SimpleGatekeeperSuicide) (event.Subscription, error)

+ type SimpleGatekeeperOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type SimpleGatekeeperOwnershipTransferredIterator struct

+ Event *SimpleGatekeeperOwnershipTransferred

+ func (it *SimpleGatekeeperOwnershipTransferredIterator) Close() error

+ func (it *SimpleGatekeeperOwnershipTransferredIterator) Error() error

+ func (it *SimpleGatekeeperOwnershipTransferredIterator) Next() bool

+ type SimpleGatekeeperPayInTx struct

+ From common.Address

+ Raw types.Log

+ TxNumber *big.Int

+ Value *big.Int

+ type SimpleGatekeeperPayInTxIterator struct

+ Event *SimpleGatekeeperPayInTx

+ func (it *SimpleGatekeeperPayInTxIterator) Close() error

+ func (it *SimpleGatekeeperPayInTxIterator) Error() error

+ func (it *SimpleGatekeeperPayInTxIterator) Next() bool

+ type SimpleGatekeeperPayoutTx struct

+ From common.Address

+ Raw types.Log

+ TxNumber *big.Int

+ Value *big.Int

+ type SimpleGatekeeperPayoutTxIterator struct

+ Event *SimpleGatekeeperPayoutTx

+ func (it *SimpleGatekeeperPayoutTxIterator) Close() error

+ func (it *SimpleGatekeeperPayoutTxIterator) Error() error

+ func (it *SimpleGatekeeperPayoutTxIterator) Next() bool

+ type SimpleGatekeeperRaw struct

+ Contract *SimpleGatekeeper

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

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

+ func (_SimpleGatekeeper *SimpleGatekeeperRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SimpleGatekeeperSession struct

+ CallOpts bind.CallOpts

+ Contract *SimpleGatekeeper

+ TransactOpts bind.TransactOpts

+ func (_SimpleGatekeeper *SimpleGatekeeperSession) Kill() (*types.Transaction, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperSession) Owner() (common.Address, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperSession) Paid(arg0 [32]byte) (bool, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperSession) PayIn(_value *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperSession) Payout(_to common.Address, _value *big.Int, _txNumber *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperSession) TransactionAmount() (*big.Int, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type SimpleGatekeeperSuicide struct

+ Block *big.Int

+ Raw types.Log

+ type SimpleGatekeeperSuicideIterator struct

+ Event *SimpleGatekeeperSuicide

+ func (it *SimpleGatekeeperSuicideIterator) Close() error

+ func (it *SimpleGatekeeperSuicideIterator) Error() error

+ func (it *SimpleGatekeeperSuicideIterator) Next() bool

+ type SimpleGatekeeperTransactor struct

+ func NewSimpleGatekeeperTransactor(address common.Address, transactor bind.ContractTransactor) (*SimpleGatekeeperTransactor, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperTransactor) PayIn(opts *bind.TransactOpts, _value *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperTransactor) Payout(opts *bind.TransactOpts, _to common.Address, _value *big.Int, ...) (*types.Transaction, error)

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

+ type SimpleGatekeeperTransactorRaw struct

+ Contract *SimpleGatekeeperTransactor

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

+ func (_SimpleGatekeeper *SimpleGatekeeperTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SimpleGatekeeperTransactorSession struct

+ Contract *SimpleGatekeeperTransactor

+ TransactOpts bind.TransactOpts

+ func (_SimpleGatekeeper *SimpleGatekeeperTransactorSession) Kill() (*types.Transaction, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperTransactorSession) PayIn(_value *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperTransactorSession) Payout(_to common.Address, _value *big.Int, _txNumber *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeper *SimpleGatekeeperTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type SimpleGatekeeperWithLimit struct

+ func DeploySimpleGatekeeperWithLimit(auth *bind.TransactOpts, backend bind.ContractBackend, _token common.Address, ...) (common.Address, *types.Transaction, *SimpleGatekeeperWithLimit, error)

+ func NewSimpleGatekeeperWithLimit(address common.Address, backend bind.ContractBackend) (*SimpleGatekeeperWithLimit, error)

+ type SimpleGatekeeperWithLimitCaller struct

+ func NewSimpleGatekeeperWithLimitCaller(address common.Address, caller bind.ContractCaller) (*SimpleGatekeeperWithLimitCaller, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitCaller) Commission(opts *bind.CallOpts) (*big.Int, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitCaller) CommissionBalance(opts *bind.CallOpts) (*big.Int, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitCaller) GetCommission(opts *bind.CallOpts) (*big.Int, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitCaller) GetFreezingTime(opts *bind.CallOpts) (*big.Int, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitCaller) Keepers(opts *bind.CallOpts, arg0 common.Address) (struct{ ... }, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitCaller) Paid(opts *bind.CallOpts, arg0 [32]byte) (struct{ ... }, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitCaller) TransactionAmount(opts *bind.CallOpts) (*big.Int, error)

+ type SimpleGatekeeperWithLimitCallerRaw struct

+ Contract *SimpleGatekeeperWithLimitCaller

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

+ type SimpleGatekeeperWithLimitCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SimpleGatekeeperWithLimitCaller

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitCallerSession) Commission() (*big.Int, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitCallerSession) CommissionBalance() (*big.Int, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitCallerSession) GetCommission() (*big.Int, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitCallerSession) GetFreezingTime() (*big.Int, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitCallerSession) Keepers(arg0 common.Address) (struct{ ... }, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitCallerSession) Owner() (common.Address, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitCallerSession) Paid(arg0 [32]byte) (struct{ ... }, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitCallerSession) TransactionAmount() (*big.Int, error)

+ type SimpleGatekeeperWithLimitCommissionChanged struct

+ Commission *big.Int

+ Raw types.Log

+ type SimpleGatekeeperWithLimitCommissionChangedIterator struct

+ Event *SimpleGatekeeperWithLimitCommissionChanged

+ func (it *SimpleGatekeeperWithLimitCommissionChangedIterator) Close() error

+ func (it *SimpleGatekeeperWithLimitCommissionChangedIterator) Error() error

+ func (it *SimpleGatekeeperWithLimitCommissionChangedIterator) Next() bool

+ type SimpleGatekeeperWithLimitCommitTx struct

+ CommitTimestamp *big.Int

+ From common.Address

+ Raw types.Log

+ TxNumber *big.Int

+ Value *big.Int

+ type SimpleGatekeeperWithLimitCommitTxIterator struct

+ Event *SimpleGatekeeperWithLimitCommitTx

+ func (it *SimpleGatekeeperWithLimitCommitTxIterator) Close() error

+ func (it *SimpleGatekeeperWithLimitCommitTxIterator) Error() error

+ func (it *SimpleGatekeeperWithLimitCommitTxIterator) Next() bool

+ type SimpleGatekeeperWithLimitFilterer struct

+ func NewSimpleGatekeeperWithLimitFilterer(address common.Address, filterer bind.ContractFilterer) (*SimpleGatekeeperWithLimitFilterer, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitFilterer) FilterCommissionChanged(opts *bind.FilterOpts, commission []*big.Int) (*SimpleGatekeeperWithLimitCommissionChangedIterator, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitFilterer) FilterCommitTx(opts *bind.FilterOpts, from []common.Address, txNumber []*big.Int, ...) (*SimpleGatekeeperWithLimitCommitTxIterator, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitFilterer) FilterKeeperFreezed(opts *bind.FilterOpts, keeper []common.Address) (*SimpleGatekeeperWithLimitKeeperFreezedIterator, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitFilterer) FilterKeeperUnfreezed(opts *bind.FilterOpts, keeper []common.Address) (*SimpleGatekeeperWithLimitKeeperUnfreezedIterator, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitFilterer) FilterLimitChanged(opts *bind.FilterOpts, keeper []common.Address, dayLimit []*big.Int) (*SimpleGatekeeperWithLimitLimitChangedIterator, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*SimpleGatekeeperWithLimitOwnershipTransferredIterator, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitFilterer) FilterPayinTx(opts *bind.FilterOpts, from []common.Address, txNumber []*big.Int, ...) (*SimpleGatekeeperWithLimitPayinTxIterator, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitFilterer) FilterPayoutTx(opts *bind.FilterOpts, from []common.Address, txNumber []*big.Int, ...) (*SimpleGatekeeperWithLimitPayoutTxIterator, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitFilterer) FilterSuicide(opts *bind.FilterOpts) (*SimpleGatekeeperWithLimitSuicideIterator, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitFilterer) WatchCommissionChanged(opts *bind.WatchOpts, sink chan<- *SimpleGatekeeperWithLimitCommissionChanged, ...) (event.Subscription, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitFilterer) WatchCommitTx(opts *bind.WatchOpts, sink chan<- *SimpleGatekeeperWithLimitCommitTx, ...) (event.Subscription, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitFilterer) WatchKeeperFreezed(opts *bind.WatchOpts, sink chan<- *SimpleGatekeeperWithLimitKeeperFreezed, ...) (event.Subscription, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitFilterer) WatchKeeperUnfreezed(opts *bind.WatchOpts, sink chan<- *SimpleGatekeeperWithLimitKeeperUnfreezed, ...) (event.Subscription, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitFilterer) WatchLimitChanged(opts *bind.WatchOpts, sink chan<- *SimpleGatekeeperWithLimitLimitChanged, ...) (event.Subscription, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitFilterer) WatchPayinTx(opts *bind.WatchOpts, sink chan<- *SimpleGatekeeperWithLimitPayinTx, ...) (event.Subscription, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitFilterer) WatchPayoutTx(opts *bind.WatchOpts, sink chan<- *SimpleGatekeeperWithLimitPayoutTx, ...) (event.Subscription, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitFilterer) WatchSuicide(opts *bind.WatchOpts, sink chan<- *SimpleGatekeeperWithLimitSuicide) (event.Subscription, error)

+ type SimpleGatekeeperWithLimitKeeperFreezed struct

+ Keeper common.Address

+ Raw types.Log

+ type SimpleGatekeeperWithLimitKeeperFreezedIterator struct

+ Event *SimpleGatekeeperWithLimitKeeperFreezed

+ func (it *SimpleGatekeeperWithLimitKeeperFreezedIterator) Close() error

+ func (it *SimpleGatekeeperWithLimitKeeperFreezedIterator) Error() error

+ func (it *SimpleGatekeeperWithLimitKeeperFreezedIterator) Next() bool

+ type SimpleGatekeeperWithLimitKeeperUnfreezed struct

+ Keeper common.Address

+ Raw types.Log

+ type SimpleGatekeeperWithLimitKeeperUnfreezedIterator struct

+ Event *SimpleGatekeeperWithLimitKeeperUnfreezed

+ func (it *SimpleGatekeeperWithLimitKeeperUnfreezedIterator) Close() error

+ func (it *SimpleGatekeeperWithLimitKeeperUnfreezedIterator) Error() error

+ func (it *SimpleGatekeeperWithLimitKeeperUnfreezedIterator) Next() bool

+ type SimpleGatekeeperWithLimitLimitChanged struct

+ DayLimit *big.Int

+ Keeper common.Address

+ Raw types.Log

+ type SimpleGatekeeperWithLimitLimitChangedIterator struct

+ Event *SimpleGatekeeperWithLimitLimitChanged

+ func (it *SimpleGatekeeperWithLimitLimitChangedIterator) Close() error

+ func (it *SimpleGatekeeperWithLimitLimitChangedIterator) Error() error

+ func (it *SimpleGatekeeperWithLimitLimitChangedIterator) Next() bool

+ type SimpleGatekeeperWithLimitLive struct

+ func DeploySimpleGatekeeperWithLimitLive(auth *bind.TransactOpts, backend bind.ContractBackend, _token common.Address, ...) (common.Address, *types.Transaction, *SimpleGatekeeperWithLimitLive, error)

+ func NewSimpleGatekeeperWithLimitLive(address common.Address, backend bind.ContractBackend) (*SimpleGatekeeperWithLimitLive, error)

+ type SimpleGatekeeperWithLimitLiveCaller struct

+ func NewSimpleGatekeeperWithLimitLiveCaller(address common.Address, caller bind.ContractCaller) (*SimpleGatekeeperWithLimitLiveCaller, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveCaller) GetFreezingTime(opts *bind.CallOpts) (*big.Int, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveCaller) Keepers(opts *bind.CallOpts, arg0 common.Address) (struct{ ... }, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveCaller) Paid(opts *bind.CallOpts, arg0 [32]byte) (struct{ ... }, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveCaller) TransactionAmount(opts *bind.CallOpts) (*big.Int, error)

+ type SimpleGatekeeperWithLimitLiveCallerRaw struct

+ Contract *SimpleGatekeeperWithLimitLiveCaller

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

+ type SimpleGatekeeperWithLimitLiveCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SimpleGatekeeperWithLimitLiveCaller

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveCallerSession) GetFreezingTime() (*big.Int, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveCallerSession) Keepers(arg0 common.Address) (struct{ ... }, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveCallerSession) Owner() (common.Address, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveCallerSession) Paid(arg0 [32]byte) (struct{ ... }, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveCallerSession) TransactionAmount() (*big.Int, error)

+ type SimpleGatekeeperWithLimitLiveCommitTx struct

+ CommitTimestamp *big.Int

+ From common.Address

+ Raw types.Log

+ TxNumber *big.Int

+ Value *big.Int

+ type SimpleGatekeeperWithLimitLiveCommitTxIterator struct

+ Event *SimpleGatekeeperWithLimitLiveCommitTx

+ func (it *SimpleGatekeeperWithLimitLiveCommitTxIterator) Close() error

+ func (it *SimpleGatekeeperWithLimitLiveCommitTxIterator) Error() error

+ func (it *SimpleGatekeeperWithLimitLiveCommitTxIterator) Next() bool

+ type SimpleGatekeeperWithLimitLiveFilterer struct

+ func NewSimpleGatekeeperWithLimitLiveFilterer(address common.Address, filterer bind.ContractFilterer) (*SimpleGatekeeperWithLimitLiveFilterer, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveFilterer) FilterCommitTx(opts *bind.FilterOpts, from []common.Address, txNumber []*big.Int, ...) (*SimpleGatekeeperWithLimitLiveCommitTxIterator, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveFilterer) FilterKeeperFreezed(opts *bind.FilterOpts, keeper []common.Address) (*SimpleGatekeeperWithLimitLiveKeeperFreezedIterator, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveFilterer) FilterKeeperUnfreezed(opts *bind.FilterOpts, keeper []common.Address) (*SimpleGatekeeperWithLimitLiveKeeperUnfreezedIterator, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveFilterer) FilterLimitChanged(opts *bind.FilterOpts, keeper []common.Address, dayLimit []*big.Int) (*SimpleGatekeeperWithLimitLiveLimitChangedIterator, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*SimpleGatekeeperWithLimitLiveOwnershipTransferredIterator, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveFilterer) FilterPayinTx(opts *bind.FilterOpts, from []common.Address, txNumber []*big.Int, ...) (*SimpleGatekeeperWithLimitLivePayinTxIterator, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveFilterer) FilterPayoutTx(opts *bind.FilterOpts, from []common.Address, txNumber []*big.Int, ...) (*SimpleGatekeeperWithLimitLivePayoutTxIterator, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveFilterer) FilterSuicide(opts *bind.FilterOpts) (*SimpleGatekeeperWithLimitLiveSuicideIterator, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveFilterer) WatchCommitTx(opts *bind.WatchOpts, sink chan<- *SimpleGatekeeperWithLimitLiveCommitTx, ...) (event.Subscription, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveFilterer) WatchKeeperFreezed(opts *bind.WatchOpts, sink chan<- *SimpleGatekeeperWithLimitLiveKeeperFreezed, ...) (event.Subscription, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveFilterer) WatchKeeperUnfreezed(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveFilterer) WatchLimitChanged(opts *bind.WatchOpts, sink chan<- *SimpleGatekeeperWithLimitLiveLimitChanged, ...) (event.Subscription, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveFilterer) WatchPayinTx(opts *bind.WatchOpts, sink chan<- *SimpleGatekeeperWithLimitLivePayinTx, ...) (event.Subscription, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveFilterer) WatchPayoutTx(opts *bind.WatchOpts, sink chan<- *SimpleGatekeeperWithLimitLivePayoutTx, ...) (event.Subscription, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveFilterer) WatchSuicide(opts *bind.WatchOpts, sink chan<- *SimpleGatekeeperWithLimitLiveSuicide) (event.Subscription, error)

+ type SimpleGatekeeperWithLimitLiveKeeperFreezed struct

+ Keeper common.Address

+ Raw types.Log

+ type SimpleGatekeeperWithLimitLiveKeeperFreezedIterator struct

+ Event *SimpleGatekeeperWithLimitLiveKeeperFreezed

+ func (it *SimpleGatekeeperWithLimitLiveKeeperFreezedIterator) Close() error

+ func (it *SimpleGatekeeperWithLimitLiveKeeperFreezedIterator) Error() error

+ func (it *SimpleGatekeeperWithLimitLiveKeeperFreezedIterator) Next() bool

+ type SimpleGatekeeperWithLimitLiveKeeperUnfreezed struct

+ Keeper common.Address

+ Raw types.Log

+ type SimpleGatekeeperWithLimitLiveKeeperUnfreezedIterator struct

+ Event *SimpleGatekeeperWithLimitLiveKeeperUnfreezed

+ func (it *SimpleGatekeeperWithLimitLiveKeeperUnfreezedIterator) Close() error

+ func (it *SimpleGatekeeperWithLimitLiveKeeperUnfreezedIterator) Error() error

+ func (it *SimpleGatekeeperWithLimitLiveKeeperUnfreezedIterator) Next() bool

+ type SimpleGatekeeperWithLimitLiveLimitChanged struct

+ DayLimit *big.Int

+ Keeper common.Address

+ Raw types.Log

+ type SimpleGatekeeperWithLimitLiveLimitChangedIterator struct

+ Event *SimpleGatekeeperWithLimitLiveLimitChanged

+ func (it *SimpleGatekeeperWithLimitLiveLimitChangedIterator) Close() error

+ func (it *SimpleGatekeeperWithLimitLiveLimitChangedIterator) Error() error

+ func (it *SimpleGatekeeperWithLimitLiveLimitChangedIterator) Next() bool

+ type SimpleGatekeeperWithLimitLiveOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type SimpleGatekeeperWithLimitLiveOwnershipTransferredIterator struct

+ Event *SimpleGatekeeperWithLimitLiveOwnershipTransferred

+ func (it *SimpleGatekeeperWithLimitLiveOwnershipTransferredIterator) Close() error

+ func (it *SimpleGatekeeperWithLimitLiveOwnershipTransferredIterator) Error() error

+ func (it *SimpleGatekeeperWithLimitLiveOwnershipTransferredIterator) Next() bool

+ type SimpleGatekeeperWithLimitLivePayinTx struct

+ From common.Address

+ Raw types.Log

+ TxNumber *big.Int

+ Value *big.Int

+ type SimpleGatekeeperWithLimitLivePayinTxIterator struct

+ Event *SimpleGatekeeperWithLimitLivePayinTx

+ func (it *SimpleGatekeeperWithLimitLivePayinTxIterator) Close() error

+ func (it *SimpleGatekeeperWithLimitLivePayinTxIterator) Error() error

+ func (it *SimpleGatekeeperWithLimitLivePayinTxIterator) Next() bool

+ type SimpleGatekeeperWithLimitLivePayoutTx struct

+ From common.Address

+ Raw types.Log

+ TxNumber *big.Int

+ Value *big.Int

+ type SimpleGatekeeperWithLimitLivePayoutTxIterator struct

+ Event *SimpleGatekeeperWithLimitLivePayoutTx

+ func (it *SimpleGatekeeperWithLimitLivePayoutTxIterator) Close() error

+ func (it *SimpleGatekeeperWithLimitLivePayoutTxIterator) Error() error

+ func (it *SimpleGatekeeperWithLimitLivePayoutTxIterator) Next() bool

+ type SimpleGatekeeperWithLimitLiveRaw struct

+ Contract *SimpleGatekeeperWithLimitLive

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

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

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SimpleGatekeeperWithLimitLiveSession struct

+ CallOpts bind.CallOpts

+ Contract *SimpleGatekeeperWithLimitLive

+ TransactOpts bind.TransactOpts

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveSession) ChangeKeeperLimit(_keeper common.Address, _limit *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveSession) FreezeKeeper(_keeper common.Address) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveSession) GetFreezingTime() (*big.Int, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveSession) Keepers(arg0 common.Address) (struct{ ... }, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveSession) Kill() (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveSession) Owner() (common.Address, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveSession) Paid(arg0 [32]byte) (struct{ ... }, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveSession) Payin(_value *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveSession) Payout(_to common.Address, _value *big.Int, _txNumber *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveSession) SetFreezingTime(_freezingTime *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveSession) TransactionAmount() (*big.Int, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveSession) UnfreezeKeeper(_keeper common.Address) (*types.Transaction, error)

+ type SimpleGatekeeperWithLimitLiveSuicide struct

+ Block *big.Int

+ Raw types.Log

+ type SimpleGatekeeperWithLimitLiveSuicideIterator struct

+ Event *SimpleGatekeeperWithLimitLiveSuicide

+ func (it *SimpleGatekeeperWithLimitLiveSuicideIterator) Close() error

+ func (it *SimpleGatekeeperWithLimitLiveSuicideIterator) Error() error

+ func (it *SimpleGatekeeperWithLimitLiveSuicideIterator) Next() bool

+ type SimpleGatekeeperWithLimitLiveTransactor struct

+ func NewSimpleGatekeeperWithLimitLiveTransactor(address common.Address, transactor bind.ContractTransactor) (*SimpleGatekeeperWithLimitLiveTransactor, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveTransactor) ChangeKeeperLimit(opts *bind.TransactOpts, _keeper common.Address, _limit *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveTransactor) FreezeKeeper(opts *bind.TransactOpts, _keeper common.Address) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveTransactor) Payin(opts *bind.TransactOpts, _value *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveTransactor) Payout(opts *bind.TransactOpts, _to common.Address, _value *big.Int, ...) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveTransactor) SetFreezingTime(opts *bind.TransactOpts, _freezingTime *big.Int) (*types.Transaction, error)

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

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveTransactor) UnfreezeKeeper(opts *bind.TransactOpts, _keeper common.Address) (*types.Transaction, error)

+ type SimpleGatekeeperWithLimitLiveTransactorRaw struct

+ Contract *SimpleGatekeeperWithLimitLiveTransactor

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

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SimpleGatekeeperWithLimitLiveTransactorSession struct

+ Contract *SimpleGatekeeperWithLimitLiveTransactor

+ TransactOpts bind.TransactOpts

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveTransactorSession) ChangeKeeperLimit(_keeper common.Address, _limit *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveTransactorSession) FreezeKeeper(_keeper common.Address) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveTransactorSession) Kill() (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveTransactorSession) Payin(_value *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveTransactorSession) Payout(_to common.Address, _value *big.Int, _txNumber *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveTransactorSession) SetFreezingTime(_freezingTime *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimitLive *SimpleGatekeeperWithLimitLiveTransactorSession) UnfreezeKeeper(_keeper common.Address) (*types.Transaction, error)

+ type SimpleGatekeeperWithLimitOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type SimpleGatekeeperWithLimitOwnershipTransferredIterator struct

+ Event *SimpleGatekeeperWithLimitOwnershipTransferred

+ func (it *SimpleGatekeeperWithLimitOwnershipTransferredIterator) Close() error

+ func (it *SimpleGatekeeperWithLimitOwnershipTransferredIterator) Error() error

+ func (it *SimpleGatekeeperWithLimitOwnershipTransferredIterator) Next() bool

+ type SimpleGatekeeperWithLimitPayinTx struct

+ From common.Address

+ Raw types.Log

+ TxNumber *big.Int

+ Value *big.Int

+ type SimpleGatekeeperWithLimitPayinTxIterator struct

+ Event *SimpleGatekeeperWithLimitPayinTx

+ func (it *SimpleGatekeeperWithLimitPayinTxIterator) Close() error

+ func (it *SimpleGatekeeperWithLimitPayinTxIterator) Error() error

+ func (it *SimpleGatekeeperWithLimitPayinTxIterator) Next() bool

+ type SimpleGatekeeperWithLimitPayoutTx struct

+ From common.Address

+ Raw types.Log

+ TxNumber *big.Int

+ Value *big.Int

+ type SimpleGatekeeperWithLimitPayoutTxIterator struct

+ Event *SimpleGatekeeperWithLimitPayoutTx

+ func (it *SimpleGatekeeperWithLimitPayoutTxIterator) Close() error

+ func (it *SimpleGatekeeperWithLimitPayoutTxIterator) Error() error

+ func (it *SimpleGatekeeperWithLimitPayoutTxIterator) Next() bool

+ type SimpleGatekeeperWithLimitRaw struct

+ Contract *SimpleGatekeeperWithLimit

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

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

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SimpleGatekeeperWithLimitSession struct

+ CallOpts bind.CallOpts

+ Contract *SimpleGatekeeperWithLimit

+ TransactOpts bind.TransactOpts

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitSession) ChangeKeeperLimit(_keeper common.Address, _limit *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitSession) Commission() (*big.Int, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitSession) CommissionBalance() (*big.Int, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitSession) FreezeKeeper(_keeper common.Address) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitSession) GetCommission() (*big.Int, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitSession) GetFreezingTime() (*big.Int, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitSession) Keepers(arg0 common.Address) (struct{ ... }, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitSession) Kill() (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitSession) Owner() (common.Address, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitSession) Paid(arg0 [32]byte) (struct{ ... }, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitSession) Payin(_value *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitSession) Payout(_to common.Address, _value *big.Int, _txNumber *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitSession) SetCommission(_commission *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitSession) SetFreezingTime(_freezingTime *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitSession) TransactionAmount() (*big.Int, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitSession) TransferCommission() (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitSession) UnfreezeKeeper(_keeper common.Address) (*types.Transaction, error)

+ type SimpleGatekeeperWithLimitSuicide struct

+ Block *big.Int

+ Raw types.Log

+ type SimpleGatekeeperWithLimitSuicideIterator struct

+ Event *SimpleGatekeeperWithLimitSuicide

+ func (it *SimpleGatekeeperWithLimitSuicideIterator) Close() error

+ func (it *SimpleGatekeeperWithLimitSuicideIterator) Error() error

+ func (it *SimpleGatekeeperWithLimitSuicideIterator) Next() bool

+ type SimpleGatekeeperWithLimitTransactor struct

+ func NewSimpleGatekeeperWithLimitTransactor(address common.Address, transactor bind.ContractTransactor) (*SimpleGatekeeperWithLimitTransactor, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactor) ChangeKeeperLimit(opts *bind.TransactOpts, _keeper common.Address, _limit *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactor) FreezeKeeper(opts *bind.TransactOpts, _keeper common.Address) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactor) Payin(opts *bind.TransactOpts, _value *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactor) Payout(opts *bind.TransactOpts, _to common.Address, _value *big.Int, ...) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactor) SetCommission(opts *bind.TransactOpts, _commission *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactor) SetFreezingTime(opts *bind.TransactOpts, _freezingTime *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactor) TransferCommission(opts *bind.TransactOpts) (*types.Transaction, error)

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

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactor) UnfreezeKeeper(opts *bind.TransactOpts, _keeper common.Address) (*types.Transaction, error)

+ type SimpleGatekeeperWithLimitTransactorRaw struct

+ Contract *SimpleGatekeeperWithLimitTransactor

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

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SimpleGatekeeperWithLimitTransactorSession struct

+ Contract *SimpleGatekeeperWithLimitTransactor

+ TransactOpts bind.TransactOpts

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactorSession) ChangeKeeperLimit(_keeper common.Address, _limit *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactorSession) FreezeKeeper(_keeper common.Address) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactorSession) Kill() (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactorSession) Payin(_value *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactorSession) Payout(_to common.Address, _value *big.Int, _txNumber *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactorSession) SetCommission(_commission *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactorSession) SetFreezingTime(_freezingTime *big.Int) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactorSession) TransferCommission() (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_SimpleGatekeeperWithLimit *SimpleGatekeeperWithLimitTransactorSession) UnfreezeKeeper(_keeper common.Address) (*types.Transaction, error)

+ type StandardToken struct

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

+ func NewStandardToken(address common.Address, backend bind.ContractBackend) (*StandardToken, error)

+ type StandardTokenApproval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type StandardTokenApprovalIterator struct

+ Event *StandardTokenApproval

+ func (it *StandardTokenApprovalIterator) Close() error

+ func (it *StandardTokenApprovalIterator) Error() error

+ func (it *StandardTokenApprovalIterator) Next() bool

+ type StandardTokenCaller struct

+ func NewStandardTokenCaller(address common.Address, caller bind.ContractCaller) (*StandardTokenCaller, error)

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

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

+ func (_StandardToken *StandardTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type StandardTokenCallerRaw struct

+ Contract *StandardTokenCaller

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

+ type StandardTokenCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *StandardTokenCaller

+ func (_StandardToken *StandardTokenCallerSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error)

+ func (_StandardToken *StandardTokenCallerSession) BalanceOf(_owner common.Address) (*big.Int, error)

+ func (_StandardToken *StandardTokenCallerSession) TotalSupply() (*big.Int, error)

+ type StandardTokenFilterer struct

+ func NewStandardTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*StandardTokenFilterer, error)

+ func (_StandardToken *StandardTokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*StandardTokenApprovalIterator, error)

+ func (_StandardToken *StandardTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*StandardTokenTransferIterator, error)

+ func (_StandardToken *StandardTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *StandardTokenApproval, ...) (event.Subscription, error)

+ func (_StandardToken *StandardTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *StandardTokenTransfer, ...) (event.Subscription, error)

+ type StandardTokenRaw struct

+ Contract *StandardToken

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

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

+ func (_StandardToken *StandardTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type StandardTokenSession struct

+ CallOpts bind.CallOpts

+ Contract *StandardToken

+ TransactOpts bind.TransactOpts

+ func (_StandardToken *StandardTokenSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error)

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

+ func (_StandardToken *StandardTokenSession) BalanceOf(_owner common.Address) (*big.Int, error)

+ func (_StandardToken *StandardTokenSession) DecreaseApproval(_spender common.Address, _subtractedValue *big.Int) (*types.Transaction, error)

+ func (_StandardToken *StandardTokenSession) IncreaseApproval(_spender common.Address, _addedValue *big.Int) (*types.Transaction, error)

+ func (_StandardToken *StandardTokenSession) TotalSupply() (*big.Int, error)

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

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

+ type StandardTokenTransactor struct

+ func NewStandardTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*StandardTokenTransactor, error)

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

+ func (_StandardToken *StandardTokenTransactor) DecreaseApproval(opts *bind.TransactOpts, _spender common.Address, _subtractedValue *big.Int) (*types.Transaction, error)

+ func (_StandardToken *StandardTokenTransactor) IncreaseApproval(opts *bind.TransactOpts, _spender common.Address, _addedValue *big.Int) (*types.Transaction, error)

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

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

+ type StandardTokenTransactorRaw struct

+ Contract *StandardTokenTransactor

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

+ func (_StandardToken *StandardTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type StandardTokenTransactorSession struct

+ Contract *StandardTokenTransactor

+ TransactOpts bind.TransactOpts

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

+ func (_StandardToken *StandardTokenTransactorSession) DecreaseApproval(_spender common.Address, _subtractedValue *big.Int) (*types.Transaction, error)

+ func (_StandardToken *StandardTokenTransactorSession) IncreaseApproval(_spender common.Address, _addedValue *big.Int) (*types.Transaction, error)

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

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

+ type StandardTokenTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type StandardTokenTransferIterator struct

+ Event *StandardTokenTransfer

+ func (it *StandardTokenTransferIterator) Close() error

+ func (it *StandardTokenTransferIterator) Error() error

+ func (it *StandardTokenTransferIterator) Next() bool

+ type TestnetFaucet struct

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

+ func NewTestnetFaucet(address common.Address, backend bind.ContractBackend) (*TestnetFaucet, error)

+ type TestnetFaucetCaller struct

+ func NewTestnetFaucetCaller(address common.Address, caller bind.ContractCaller) (*TestnetFaucetCaller, error)

+ func (_TestnetFaucet *TestnetFaucetCaller) GetTokenAddress(opts *bind.CallOpts) (common.Address, error)

+ func (_TestnetFaucet *TestnetFaucetCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ type TestnetFaucetCallerRaw struct

+ Contract *TestnetFaucetCaller

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

+ type TestnetFaucetCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *TestnetFaucetCaller

+ func (_TestnetFaucet *TestnetFaucetCallerSession) GetTokenAddress() (common.Address, error)

+ func (_TestnetFaucet *TestnetFaucetCallerSession) Owner() (common.Address, error)

+ type TestnetFaucetFilterer struct

+ func NewTestnetFaucetFilterer(address common.Address, filterer bind.ContractFilterer) (*TestnetFaucetFilterer, error)

+ func (_TestnetFaucet *TestnetFaucetFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*TestnetFaucetOwnershipTransferredIterator, error)

+ func (_TestnetFaucet *TestnetFaucetFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *TestnetFaucetOwnershipTransferred, ...) (event.Subscription, error)

+ type TestnetFaucetOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type TestnetFaucetOwnershipTransferredIterator struct

+ Event *TestnetFaucetOwnershipTransferred

+ func (it *TestnetFaucetOwnershipTransferredIterator) Close() error

+ func (it *TestnetFaucetOwnershipTransferredIterator) Error() error

+ func (it *TestnetFaucetOwnershipTransferredIterator) Next() bool

+ type TestnetFaucetRaw struct

+ Contract *TestnetFaucet

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

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

+ func (_TestnetFaucet *TestnetFaucetRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type TestnetFaucetSession struct

+ CallOpts bind.CallOpts

+ Contract *TestnetFaucet

+ TransactOpts bind.TransactOpts

+ func (_TestnetFaucet *TestnetFaucetSession) GetTokenAddress() (common.Address, error)

+ func (_TestnetFaucet *TestnetFaucetSession) GetTokens() (*types.Transaction, error)

+ func (_TestnetFaucet *TestnetFaucetSession) MintToken(target common.Address, mintedAmount *big.Int) (*types.Transaction, error)

+ func (_TestnetFaucet *TestnetFaucetSession) Owner() (common.Address, error)

+ func (_TestnetFaucet *TestnetFaucetSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type TestnetFaucetTransactor struct

+ func NewTestnetFaucetTransactor(address common.Address, transactor bind.ContractTransactor) (*TestnetFaucetTransactor, error)

+ func (_TestnetFaucet *TestnetFaucetTransactor) GetTokens(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_TestnetFaucet *TestnetFaucetTransactor) MintToken(opts *bind.TransactOpts, target common.Address, mintedAmount *big.Int) (*types.Transaction, error)

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

+ type TestnetFaucetTransactorRaw struct

+ Contract *TestnetFaucetTransactor

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

+ func (_TestnetFaucet *TestnetFaucetTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type TestnetFaucetTransactorSession struct

+ Contract *TestnetFaucetTransactor

+ TransactOpts bind.TransactOpts

+ func (_TestnetFaucet *TestnetFaucetTransactorSession) GetTokens() (*types.Transaction, error)

+ func (_TestnetFaucet *TestnetFaucetTransactorSession) MintToken(target common.Address, mintedAmount *big.Int) (*types.Transaction, error)

+ func (_TestnetFaucet *TestnetFaucetTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

v0.4.0-rc1

Jun 22, 2018

v0.4.0-alpha3

Jun 8, 2018

v0.4.0-alpha2

Jun 4, 2018

v0.4.0-alpha1

May 30, 2018

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