bindings

package
v0.0.0-...-99f092e Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 29, 2019 License: MIT Imports: 8 Imported by: 0

Documentation

Index

Constants

View Source 
const ActivatableABI = "" /* 1644-byte string literal not displayed */

ActivatableABI is the input ABI used to generate the binding from.

View Source 
const DestructibleABI = "" /* 1246-byte string literal not displayed */

DestructibleABI is the input ABI used to generate the binding from.

View Source 
const MigrationsABI = "" /* 849-byte string literal not displayed */

MigrationsABI is the input ABI used to generate the binding from.

View Source 
const OwnableABI = "" /* 995-byte string literal not displayed */

OwnableABI is the input ABI used to generate the binding from.

View Source 
const PausableABI = "" /* 1512-byte string literal not displayed */

PausableABI is the input ABI used to generate the binding from.

View Source 
const RoomABI = "" /* 4194-byte string literal not displayed */

RoomABI is the input ABI used to generate the binding from.

View Source 
const RoomFactoryABI = "" /* 2273-byte string literal not displayed */

RoomFactoryABI is the input ABI used to generate the binding from.

Variables

This section is empty.

Functions

This section is empty.

Types

type Activatable 

type Activatable struct {
	ActivatableCaller     // Read-only binding to the contract
	ActivatableTransactor // Write-only binding to the contract
	ActivatableFilterer   // Log filterer for contract events
}

Activatable is an auto generated Go binding around an Ethereum contract.

func NewActivatable 

func NewActivatable(address common.Address, backend bind.ContractBackend) (*Activatable, error)

NewActivatable creates a new instance of Activatable, bound to a specific deployed contract.

type ActivatableActivate 

type ActivatableActivate struct {
	Sender common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

ActivatableActivate represents a Activate event raised by the Activatable contract.

type ActivatableActivateIterator 

type ActivatableActivateIterator struct {
	Event *ActivatableActivate // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

ActivatableActivateIterator is returned from FilterActivate and is used to iterate over the raw logs and unpacked data for Activate events raised by the Activatable contract.

func (*ActivatableActivateIterator) Close 

func (it *ActivatableActivateIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*ActivatableActivateIterator) Error 

func (it *ActivatableActivateIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ActivatableActivateIterator) Next 

func (it *ActivatableActivateIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type ActivatableCaller 

type ActivatableCaller struct {
	// contains filtered or unexported fields
}

ActivatableCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewActivatableCaller 

func NewActivatableCaller(address common.Address, caller bind.ContractCaller) (*ActivatableCaller, error)

NewActivatableCaller creates a new read-only instance of Activatable, bound to a specific deployed contract.

func (*ActivatableCaller) Active 

func (_Activatable *ActivatableCaller) Active(opts *bind.CallOpts) (bool, error)

Active is a free data retrieval call binding the contract method 0x02fb0c5e.

Solidity: function active() constant returns(bool)

func (*ActivatableCaller) Owner 

func (_Activatable *ActivatableCaller) Owner(opts *bind.CallOpts) (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

type ActivatableCallerRaw 

type ActivatableCallerRaw struct {
	Contract *ActivatableCaller // Generic read-only contract binding to access the raw methods on
}

ActivatableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*ActivatableCallerRaw) Call 

func (_Activatable *ActivatableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type ActivatableCallerSession 

type ActivatableCallerSession struct {
	Contract *ActivatableCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts      // Call options to use throughout this session
}

ActivatableCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*ActivatableCallerSession) Active 

func (_Activatable *ActivatableCallerSession) Active() (bool, error)

Active is a free data retrieval call binding the contract method 0x02fb0c5e.

Solidity: function active() constant returns(bool)

func (*ActivatableCallerSession) Owner 

func (_Activatable *ActivatableCallerSession) Owner() (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

type ActivatableDeactivate 

type ActivatableDeactivate struct {
	Sender common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

ActivatableDeactivate represents a Deactivate event raised by the Activatable contract.

type ActivatableDeactivateIterator 

type ActivatableDeactivateIterator struct {
	Event *ActivatableDeactivate // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

ActivatableDeactivateIterator is returned from FilterDeactivate and is used to iterate over the raw logs and unpacked data for Deactivate events raised by the Activatable contract.

func (*ActivatableDeactivateIterator) Close 

func (it *ActivatableDeactivateIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*ActivatableDeactivateIterator) Error 

func (it *ActivatableDeactivateIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ActivatableDeactivateIterator) Next 

func (it *ActivatableDeactivateIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type ActivatableFilterer 

type ActivatableFilterer struct {
	// contains filtered or unexported fields
}

ActivatableFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewActivatableFilterer 

func NewActivatableFilterer(address common.Address, filterer bind.ContractFilterer) (*ActivatableFilterer, error)

NewActivatableFilterer creates a new log filterer instance of Activatable, bound to a specific deployed contract.

func (*ActivatableFilterer) FilterActivate 

func (_Activatable *ActivatableFilterer) FilterActivate(opts *bind.FilterOpts, _sender []common.Address) (*ActivatableActivateIterator, error)

FilterActivate is a free log retrieval operation binding the contract event 0xf7e9fe69e1d05372bc855b295bc4c34a1a0a5882164dd2b26df30a26c1c8ba15.

Solidity: e Activate(_sender indexed address)

func (*ActivatableFilterer) FilterDeactivate 

func (_Activatable *ActivatableFilterer) FilterDeactivate(opts *bind.FilterOpts, _sender []common.Address) (*ActivatableDeactivateIterator, error)

FilterDeactivate is a free log retrieval operation binding the contract event 0x238ce44d0fada9e1348f183a8436996fb52b4c41a9cbf3af6e2dee00fcb80a9c.

Solidity: e Deactivate(_sender indexed address)

func (*ActivatableFilterer) FilterOwnershipRenounced 

func (_Activatable *ActivatableFilterer) FilterOwnershipRenounced(opts *bind.FilterOpts, previousOwner []common.Address) (*ActivatableOwnershipRenouncedIterator, error)

FilterOwnershipRenounced is a free log retrieval operation binding the contract event 0xf8df31144d9c2f0f6b59d69b8b98abd5459d07f2742c4df920b25aae33c64820.

Solidity: e OwnershipRenounced(previousOwner indexed address)

func (*ActivatableFilterer) FilterOwnershipTransferred 

func (_Activatable *ActivatableFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*ActivatableOwnershipTransferredIterator, error)

FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: e OwnershipTransferred(previousOwner indexed address, newOwner indexed address)

func (*ActivatableFilterer) WatchActivate 

func (_Activatable *ActivatableFilterer) WatchActivate(opts *bind.WatchOpts, sink chan<- *ActivatableActivate, _sender []common.Address) (event.Subscription, error)

WatchActivate is a free log subscription operation binding the contract event 0xf7e9fe69e1d05372bc855b295bc4c34a1a0a5882164dd2b26df30a26c1c8ba15.

Solidity: e Activate(_sender indexed address)

func (*ActivatableFilterer) WatchDeactivate 

func (_Activatable *ActivatableFilterer) WatchDeactivate(opts *bind.WatchOpts, sink chan<- *ActivatableDeactivate, _sender []common.Address) (event.Subscription, error)

WatchDeactivate is a free log subscription operation binding the contract event 0x238ce44d0fada9e1348f183a8436996fb52b4c41a9cbf3af6e2dee00fcb80a9c.

Solidity: e Deactivate(_sender indexed address)

func (*ActivatableFilterer) WatchOwnershipRenounced 

func (_Activatable *ActivatableFilterer) WatchOwnershipRenounced(opts *bind.WatchOpts, sink chan<- *ActivatableOwnershipRenounced, previousOwner []common.Address) (event.Subscription, error)

WatchOwnershipRenounced is a free log subscription operation binding the contract event 0xf8df31144d9c2f0f6b59d69b8b98abd5459d07f2742c4df920b25aae33c64820.

Solidity: e OwnershipRenounced(previousOwner indexed address)

func (*ActivatableFilterer) WatchOwnershipTransferred 

func (_Activatable *ActivatableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *ActivatableOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: e OwnershipTransferred(previousOwner indexed address, newOwner indexed address)

type ActivatableOwnershipRenounced 

type ActivatableOwnershipRenounced struct {
	PreviousOwner common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

ActivatableOwnershipRenounced represents a OwnershipRenounced event raised by the Activatable contract.

type ActivatableOwnershipRenouncedIterator 

type ActivatableOwnershipRenouncedIterator struct {
	Event *ActivatableOwnershipRenounced // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

ActivatableOwnershipRenouncedIterator is returned from FilterOwnershipRenounced and is used to iterate over the raw logs and unpacked data for OwnershipRenounced events raised by the Activatable contract.

func (*ActivatableOwnershipRenouncedIterator) Close 

func (it *ActivatableOwnershipRenouncedIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*ActivatableOwnershipRenouncedIterator) Error 

func (it *ActivatableOwnershipRenouncedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ActivatableOwnershipRenouncedIterator) Next 

func (it *ActivatableOwnershipRenouncedIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type ActivatableOwnershipTransferred 

type ActivatableOwnershipTransferred struct {
	PreviousOwner common.Address
	NewOwner      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

ActivatableOwnershipTransferred represents a OwnershipTransferred event raised by the Activatable contract.

type ActivatableOwnershipTransferredIterator 

type ActivatableOwnershipTransferredIterator struct {
	Event *ActivatableOwnershipTransferred // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

ActivatableOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Activatable contract.

func (*ActivatableOwnershipTransferredIterator) Close 

func (it *ActivatableOwnershipTransferredIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*ActivatableOwnershipTransferredIterator) Error 

func (it *ActivatableOwnershipTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ActivatableOwnershipTransferredIterator) Next 

func (it *ActivatableOwnershipTransferredIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type ActivatableRaw 

type ActivatableRaw struct {
	Contract *Activatable // Generic contract binding to access the raw methods on
}

ActivatableRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*ActivatableRaw) Call 

func (_Activatable *ActivatableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*ActivatableRaw) Transact 

func (_Activatable *ActivatableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ActivatableRaw) Transfer 

func (_Activatable *ActivatableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ActivatableSession 

type ActivatableSession struct {
	Contract     *Activatable      // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

ActivatableSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*ActivatableSession) Activate 

func (_Activatable *ActivatableSession) Activate() (*types.Transaction, error)

Activate is a paid mutator transaction binding the contract method 0x0f15f4c0.

Solidity: function activate() returns()

func (*ActivatableSession) Active 

func (_Activatable *ActivatableSession) Active() (bool, error)

Active is a free data retrieval call binding the contract method 0x02fb0c5e.

Solidity: function active() constant returns(bool)

func (*ActivatableSession) Deactivate 

func (_Activatable *ActivatableSession) Deactivate() (*types.Transaction, error)

Deactivate is a paid mutator transaction binding the contract method 0x51b42b00.

Solidity: function deactivate() returns()

func (*ActivatableSession) Owner 

func (_Activatable *ActivatableSession) Owner() (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*ActivatableSession) RenounceOwnership 

func (_Activatable *ActivatableSession) RenounceOwnership() (*types.Transaction, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*ActivatableSession) TransferOwnership 

func (_Activatable *ActivatableSession) TransferOwnership(_newOwner common.Address) (*types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(_newOwner address) returns()

type ActivatableTransactor 

type ActivatableTransactor struct {
	// contains filtered or unexported fields
}

ActivatableTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewActivatableTransactor 

func NewActivatableTransactor(address common.Address, transactor bind.ContractTransactor) (*ActivatableTransactor, error)

NewActivatableTransactor creates a new write-only instance of Activatable, bound to a specific deployed contract.

func (*ActivatableTransactor) Activate 

func (_Activatable *ActivatableTransactor) Activate(opts *bind.TransactOpts) (*types.Transaction, error)

Activate is a paid mutator transaction binding the contract method 0x0f15f4c0.

Solidity: function activate() returns()

func (*ActivatableTransactor) Deactivate 

func (_Activatable *ActivatableTransactor) Deactivate(opts *bind.TransactOpts) (*types.Transaction, error)

Deactivate is a paid mutator transaction binding the contract method 0x51b42b00.

Solidity: function deactivate() returns()

func (*ActivatableTransactor) RenounceOwnership 

func (_Activatable *ActivatableTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*ActivatableTransactor) TransferOwnership 

func (_Activatable *ActivatableTransactor) TransferOwnership(opts *bind.TransactOpts, _newOwner common.Address) (*types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(_newOwner address) returns()

type ActivatableTransactorRaw 

type ActivatableTransactorRaw struct {
	Contract *ActivatableTransactor // Generic write-only contract binding to access the raw methods on
}

ActivatableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*ActivatableTransactorRaw) Transact 

func (_Activatable *ActivatableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ActivatableTransactorRaw) Transfer 

func (_Activatable *ActivatableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ActivatableTransactorSession 

type ActivatableTransactorSession struct {
	Contract     *ActivatableTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts      // Transaction auth options to use throughout this session
}

ActivatableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*ActivatableTransactorSession) Activate 

func (_Activatable *ActivatableTransactorSession) Activate() (*types.Transaction, error)

Activate is a paid mutator transaction binding the contract method 0x0f15f4c0.

Solidity: function activate() returns()

func (*ActivatableTransactorSession) Deactivate 

func (_Activatable *ActivatableTransactorSession) Deactivate() (*types.Transaction, error)

Deactivate is a paid mutator transaction binding the contract method 0x51b42b00.

Solidity: function deactivate() returns()

func (*ActivatableTransactorSession) RenounceOwnership 

func (_Activatable *ActivatableTransactorSession) RenounceOwnership() (*types.Transaction, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*ActivatableTransactorSession) TransferOwnership 

func (_Activatable *ActivatableTransactorSession) TransferOwnership(_newOwner common.Address) (*types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(_newOwner address) returns()

type Destructible 

type Destructible struct {
	DestructibleCaller     // Read-only binding to the contract
	DestructibleTransactor // Write-only binding to the contract
	DestructibleFilterer   // Log filterer for contract events
}

Destructible is an auto generated Go binding around an Ethereum contract.

func NewDestructible 

func NewDestructible(address common.Address, backend bind.ContractBackend) (*Destructible, error)

NewDestructible creates a new instance of Destructible, bound to a specific deployed contract.

type DestructibleCaller 

type DestructibleCaller struct {
	// contains filtered or unexported fields
}

DestructibleCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewDestructibleCaller 

func NewDestructibleCaller(address common.Address, caller bind.ContractCaller) (*DestructibleCaller, error)

NewDestructibleCaller creates a new read-only instance of Destructible, bound to a specific deployed contract.

func (*DestructibleCaller) Owner 

func (_Destructible *DestructibleCaller) Owner(opts *bind.CallOpts) (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

type DestructibleCallerRaw 

type DestructibleCallerRaw struct {
	Contract *DestructibleCaller // Generic read-only contract binding to access the raw methods on
}

DestructibleCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*DestructibleCallerRaw) Call 

func (_Destructible *DestructibleCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type DestructibleCallerSession 

type DestructibleCallerSession struct {
	Contract *DestructibleCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts       // Call options to use throughout this session
}

DestructibleCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*DestructibleCallerSession) Owner 

func (_Destructible *DestructibleCallerSession) Owner() (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

type DestructibleFilterer 

type DestructibleFilterer struct {
	// contains filtered or unexported fields
}

DestructibleFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewDestructibleFilterer 

func NewDestructibleFilterer(address common.Address, filterer bind.ContractFilterer) (*DestructibleFilterer, error)

NewDestructibleFilterer creates a new log filterer instance of Destructible, bound to a specific deployed contract.

func (*DestructibleFilterer) FilterOwnershipRenounced 

func (_Destructible *DestructibleFilterer) FilterOwnershipRenounced(opts *bind.FilterOpts, previousOwner []common.Address) (*DestructibleOwnershipRenouncedIterator, error)

FilterOwnershipRenounced is a free log retrieval operation binding the contract event 0xf8df31144d9c2f0f6b59d69b8b98abd5459d07f2742c4df920b25aae33c64820.

Solidity: e OwnershipRenounced(previousOwner indexed address)

func (*DestructibleFilterer) FilterOwnershipTransferred 

func (_Destructible *DestructibleFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*DestructibleOwnershipTransferredIterator, error)

FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: e OwnershipTransferred(previousOwner indexed address, newOwner indexed address)

func (*DestructibleFilterer) WatchOwnershipRenounced 

func (_Destructible *DestructibleFilterer) WatchOwnershipRenounced(opts *bind.WatchOpts, sink chan<- *DestructibleOwnershipRenounced, previousOwner []common.Address) (event.Subscription, error)

WatchOwnershipRenounced is a free log subscription operation binding the contract event 0xf8df31144d9c2f0f6b59d69b8b98abd5459d07f2742c4df920b25aae33c64820.

Solidity: e OwnershipRenounced(previousOwner indexed address)

func (*DestructibleFilterer) WatchOwnershipTransferred 

func (_Destructible *DestructibleFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *DestructibleOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: e OwnershipTransferred(previousOwner indexed address, newOwner indexed address)

type DestructibleOwnershipRenounced 

type DestructibleOwnershipRenounced struct {
	PreviousOwner common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

DestructibleOwnershipRenounced represents a OwnershipRenounced event raised by the Destructible contract.

type DestructibleOwnershipRenouncedIterator 

type DestructibleOwnershipRenouncedIterator struct {
	Event *DestructibleOwnershipRenounced // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

DestructibleOwnershipRenouncedIterator is returned from FilterOwnershipRenounced and is used to iterate over the raw logs and unpacked data for OwnershipRenounced events raised by the Destructible contract.

func (*DestructibleOwnershipRenouncedIterator) Close 

func (it *DestructibleOwnershipRenouncedIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*DestructibleOwnershipRenouncedIterator) Error 

func (it *DestructibleOwnershipRenouncedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DestructibleOwnershipRenouncedIterator) Next 

func (it *DestructibleOwnershipRenouncedIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type DestructibleOwnershipTransferred 

type DestructibleOwnershipTransferred struct {
	PreviousOwner common.Address
	NewOwner      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

DestructibleOwnershipTransferred represents a OwnershipTransferred event raised by the Destructible contract.

type DestructibleOwnershipTransferredIterator 

type DestructibleOwnershipTransferredIterator struct {
	Event *DestructibleOwnershipTransferred // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

DestructibleOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Destructible contract.

func (*DestructibleOwnershipTransferredIterator) Close 

func (it *DestructibleOwnershipTransferredIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*DestructibleOwnershipTransferredIterator) Error 

func (it *DestructibleOwnershipTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DestructibleOwnershipTransferredIterator) Next 

func (it *DestructibleOwnershipTransferredIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type DestructibleRaw 

type DestructibleRaw struct {
	Contract *Destructible // Generic contract binding to access the raw methods on
}

DestructibleRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*DestructibleRaw) Call 

func (_Destructible *DestructibleRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*DestructibleRaw) Transact 

func (_Destructible *DestructibleRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*DestructibleRaw) Transfer 

func (_Destructible *DestructibleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type DestructibleSession 

type DestructibleSession struct {
	Contract     *Destructible     // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

DestructibleSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*DestructibleSession) Destroy 

func (_Destructible *DestructibleSession) Destroy() (*types.Transaction, error)

Destroy is a paid mutator transaction binding the contract method 0x83197ef0.

Solidity: function destroy() returns()

func (*DestructibleSession) DestroyAndSend 

func (_Destructible *DestructibleSession) DestroyAndSend(_recipient common.Address) (*types.Transaction, error)

DestroyAndSend is a paid mutator transaction binding the contract method 0xf5074f41.

Solidity: function destroyAndSend(_recipient address) returns()

func (*DestructibleSession) Owner 

func (_Destructible *DestructibleSession) Owner() (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*DestructibleSession) RenounceOwnership 

func (_Destructible *DestructibleSession) RenounceOwnership() (*types.Transaction, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*DestructibleSession) TransferOwnership 

func (_Destructible *DestructibleSession) TransferOwnership(_newOwner common.Address) (*types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(_newOwner address) returns()

type DestructibleTransactor 

type DestructibleTransactor struct {
	// contains filtered or unexported fields
}

DestructibleTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewDestructibleTransactor 

func NewDestructibleTransactor(address common.Address, transactor bind.ContractTransactor) (*DestructibleTransactor, error)

NewDestructibleTransactor creates a new write-only instance of Destructible, bound to a specific deployed contract.

func (*DestructibleTransactor) Destroy 

func (_Destructible *DestructibleTransactor) Destroy(opts *bind.TransactOpts) (*types.Transaction, error)

Destroy is a paid mutator transaction binding the contract method 0x83197ef0.

Solidity: function destroy() returns()

func (*DestructibleTransactor) DestroyAndSend 

func (_Destructible *DestructibleTransactor) DestroyAndSend(opts *bind.TransactOpts, _recipient common.Address) (*types.Transaction, error)

DestroyAndSend is a paid mutator transaction binding the contract method 0xf5074f41.

Solidity: function destroyAndSend(_recipient address) returns()

func (*DestructibleTransactor) RenounceOwnership 

func (_Destructible *DestructibleTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*DestructibleTransactor) TransferOwnership 

func (_Destructible *DestructibleTransactor) TransferOwnership(opts *bind.TransactOpts, _newOwner common.Address) (*types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(_newOwner address) returns()

type DestructibleTransactorRaw 

type DestructibleTransactorRaw struct {
	Contract *DestructibleTransactor // Generic write-only contract binding to access the raw methods on
}

DestructibleTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*DestructibleTransactorRaw) Transact 

func (_Destructible *DestructibleTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*DestructibleTransactorRaw) Transfer 

func (_Destructible *DestructibleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type DestructibleTransactorSession 

type DestructibleTransactorSession struct {
	Contract     *DestructibleTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts       // Transaction auth options to use throughout this session
}

DestructibleTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*DestructibleTransactorSession) Destroy 

func (_Destructible *DestructibleTransactorSession) Destroy() (*types.Transaction, error)

Destroy is a paid mutator transaction binding the contract method 0x83197ef0.

Solidity: function destroy() returns()

func (*DestructibleTransactorSession) DestroyAndSend 

func (_Destructible *DestructibleTransactorSession) DestroyAndSend(_recipient common.Address) (*types.Transaction, error)

DestroyAndSend is a paid mutator transaction binding the contract method 0xf5074f41.

Solidity: function destroyAndSend(_recipient address) returns()

func (*DestructibleTransactorSession) RenounceOwnership 

func (_Destructible *DestructibleTransactorSession) RenounceOwnership() (*types.Transaction, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*DestructibleTransactorSession) TransferOwnership 

func (_Destructible *DestructibleTransactorSession) TransferOwnership(_newOwner common.Address) (*types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(_newOwner address) returns()

type Migrations 

type Migrations struct {
	MigrationsCaller     // Read-only binding to the contract
	MigrationsTransactor // Write-only binding to the contract
	MigrationsFilterer   // Log filterer for contract events
}

Migrations is an auto generated Go binding around an Ethereum contract.

func NewMigrations 

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

NewMigrations creates a new instance of Migrations, bound to a specific deployed contract.

type MigrationsCaller 

type MigrationsCaller struct {
	// contains filtered or unexported fields
}

MigrationsCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewMigrationsCaller 

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

NewMigrationsCaller creates a new read-only instance of Migrations, bound to a specific deployed contract.

func (*MigrationsCaller) LastCompletedMigration 

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

LastCompletedMigration is a free data retrieval call binding the contract method 0x445df0ac.

Solidity: function last_completed_migration() constant returns(uint256)

func (*MigrationsCaller) Owner 

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

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

type MigrationsCallerRaw 

type MigrationsCallerRaw struct {
	Contract *MigrationsCaller // Generic read-only contract binding to access the raw methods on
}

MigrationsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*MigrationsCallerRaw) Call 

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

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type MigrationsCallerSession 

type MigrationsCallerSession struct {
	Contract *MigrationsCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts     // Call options to use throughout this session
}

MigrationsCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*MigrationsCallerSession) LastCompletedMigration 

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

LastCompletedMigration is a free data retrieval call binding the contract method 0x445df0ac.

Solidity: function last_completed_migration() constant returns(uint256)

func (*MigrationsCallerSession) Owner 

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

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

type MigrationsFilterer 

type MigrationsFilterer struct {
	// contains filtered or unexported fields
}

MigrationsFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewMigrationsFilterer 

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

NewMigrationsFilterer creates a new log filterer instance of Migrations, bound to a specific deployed contract.

type MigrationsRaw 

type MigrationsRaw struct {
	Contract *Migrations // Generic contract binding to access the raw methods on
}

MigrationsRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*MigrationsRaw) Call 

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

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*MigrationsRaw) Transact 

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

Transact invokes the (paid) contract method with params as input values.

func (*MigrationsRaw) Transfer 

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

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type MigrationsSession 

type MigrationsSession struct {
	Contract     *Migrations       // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

MigrationsSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*MigrationsSession) LastCompletedMigration 

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

LastCompletedMigration is a free data retrieval call binding the contract method 0x445df0ac.

Solidity: function last_completed_migration() constant returns(uint256)

func (*MigrationsSession) Owner 

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

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*MigrationsSession) SetCompleted 

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

SetCompleted is a paid mutator transaction binding the contract method 0xfdacd576.

Solidity: function setCompleted(completed uint256) returns()

func (*MigrationsSession) Upgrade 

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

Upgrade is a paid mutator transaction binding the contract method 0x0900f010.

Solidity: function upgrade(new_address address) returns()

type MigrationsTransactor 

type MigrationsTransactor struct {
	// contains filtered or unexported fields
}

MigrationsTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewMigrationsTransactor 

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

NewMigrationsTransactor creates a new write-only instance of Migrations, bound to a specific deployed contract.

func (*MigrationsTransactor) SetCompleted 

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

SetCompleted is a paid mutator transaction binding the contract method 0xfdacd576.

Solidity: function setCompleted(completed uint256) returns()

func (*MigrationsTransactor) Upgrade 

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

Upgrade is a paid mutator transaction binding the contract method 0x0900f010.

Solidity: function upgrade(new_address address) returns()

type MigrationsTransactorRaw 

type MigrationsTransactorRaw struct {
	Contract *MigrationsTransactor // Generic write-only contract binding to access the raw methods on
}

MigrationsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*MigrationsTransactorRaw) Transact 

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

Transact invokes the (paid) contract method with params as input values.

func (*MigrationsTransactorRaw) Transfer 

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

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type MigrationsTransactorSession 

type MigrationsTransactorSession struct {
	Contract     *MigrationsTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts     // Transaction auth options to use throughout this session
}

MigrationsTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*MigrationsTransactorSession) SetCompleted 

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

SetCompleted is a paid mutator transaction binding the contract method 0xfdacd576.

Solidity: function setCompleted(completed uint256) returns()

func (*MigrationsTransactorSession) Upgrade 

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

Upgrade is a paid mutator transaction binding the contract method 0x0900f010.

Solidity: function upgrade(new_address address) returns()

type Ownable 

type Ownable struct {
	OwnableCaller     // Read-only binding to the contract
	OwnableTransactor // Write-only binding to the contract
	OwnableFilterer   // Log filterer for contract events
}

Ownable is an auto generated Go binding around an Ethereum contract.

func NewOwnable 

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

NewOwnable creates a new instance of Ownable, bound to a specific deployed contract.

type OwnableCaller 

type OwnableCaller struct {
	// contains filtered or unexported fields
}

OwnableCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewOwnableCaller 

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

NewOwnableCaller creates a new read-only instance of Ownable, bound to a specific deployed contract.

func (*OwnableCaller) Owner 

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

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

type OwnableCallerRaw 

type OwnableCallerRaw struct {
	Contract *OwnableCaller // Generic read-only contract binding to access the raw methods on
}

OwnableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*OwnableCallerRaw) Call 

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

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type OwnableCallerSession 

type OwnableCallerSession struct {
	Contract *OwnableCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts  // Call options to use throughout this session
}

OwnableCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*OwnableCallerSession) Owner 

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

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

type OwnableFilterer 

type OwnableFilterer struct {
	// contains filtered or unexported fields
}

OwnableFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewOwnableFilterer 

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

NewOwnableFilterer creates a new log filterer instance of Ownable, bound to a specific deployed contract.

func (*OwnableFilterer) FilterOwnershipRenounced 

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

FilterOwnershipRenounced is a free log retrieval operation binding the contract event 0xf8df31144d9c2f0f6b59d69b8b98abd5459d07f2742c4df920b25aae33c64820.

Solidity: e OwnershipRenounced(previousOwner indexed address)

func (*OwnableFilterer) FilterOwnershipTransferred 

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

FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: e OwnershipTransferred(previousOwner indexed address, newOwner indexed address)

func (*OwnableFilterer) WatchOwnershipRenounced 

func (_Ownable *OwnableFilterer) WatchOwnershipRenounced(opts *bind.WatchOpts, sink chan<- *OwnableOwnershipRenounced, previousOwner []common.Address) (event.Subscription, error)

WatchOwnershipRenounced is a free log subscription operation binding the contract event 0xf8df31144d9c2f0f6b59d69b8b98abd5459d07f2742c4df920b25aae33c64820.

Solidity: e OwnershipRenounced(previousOwner indexed address)

func (*OwnableFilterer) WatchOwnershipTransferred 

func (_Ownable *OwnableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OwnableOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: e OwnershipTransferred(previousOwner indexed address, newOwner indexed address)

type OwnableOwnershipRenounced 

type OwnableOwnershipRenounced struct {
	PreviousOwner common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

OwnableOwnershipRenounced represents a OwnershipRenounced event raised by the Ownable contract.

type OwnableOwnershipRenouncedIterator 

type OwnableOwnershipRenouncedIterator struct {
	Event *OwnableOwnershipRenounced // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

OwnableOwnershipRenouncedIterator is returned from FilterOwnershipRenounced and is used to iterate over the raw logs and unpacked data for OwnershipRenounced events raised by the Ownable contract.

func (*OwnableOwnershipRenouncedIterator) Close 

func (it *OwnableOwnershipRenouncedIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*OwnableOwnershipRenouncedIterator) Error 

func (it *OwnableOwnershipRenouncedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*OwnableOwnershipRenouncedIterator) Next 

func (it *OwnableOwnershipRenouncedIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type OwnableOwnershipTransferred 

type OwnableOwnershipTransferred struct {
	PreviousOwner common.Address
	NewOwner      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

OwnableOwnershipTransferred represents a OwnershipTransferred event raised by the Ownable contract.

type OwnableOwnershipTransferredIterator 

type OwnableOwnershipTransferredIterator struct {
	Event *OwnableOwnershipTransferred // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

OwnableOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Ownable contract.

func (*OwnableOwnershipTransferredIterator) Close 

func (it *OwnableOwnershipTransferredIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*OwnableOwnershipTransferredIterator) Error 

func (it *OwnableOwnershipTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*OwnableOwnershipTransferredIterator) Next 

func (it *OwnableOwnershipTransferredIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type OwnableRaw 

type OwnableRaw struct {
	Contract *Ownable // Generic contract binding to access the raw methods on
}

OwnableRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*OwnableRaw) Call 

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

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*OwnableRaw) Transact 

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

Transact invokes the (paid) contract method with params as input values.

func (*OwnableRaw) Transfer 

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

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type OwnableSession 

type OwnableSession struct {
	Contract     *Ownable          // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

OwnableSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*OwnableSession) Owner 

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

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*OwnableSession) RenounceOwnership 

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

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*OwnableSession) TransferOwnership 

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

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(_newOwner address) returns()

type OwnableTransactor 

type OwnableTransactor struct {
	// contains filtered or unexported fields
}

OwnableTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewOwnableTransactor 

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

NewOwnableTransactor creates a new write-only instance of Ownable, bound to a specific deployed contract.

func (*OwnableTransactor) RenounceOwnership 

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

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*OwnableTransactor) TransferOwnership 

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

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(_newOwner address) returns()

type OwnableTransactorRaw 

type OwnableTransactorRaw struct {
	Contract *OwnableTransactor // Generic write-only contract binding to access the raw methods on
}

OwnableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*OwnableTransactorRaw) Transact 

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

Transact invokes the (paid) contract method with params as input values.

func (*OwnableTransactorRaw) Transfer 

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

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type OwnableTransactorSession 

type OwnableTransactorSession struct {
	Contract     *OwnableTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
}

OwnableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*OwnableTransactorSession) RenounceOwnership 

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

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*OwnableTransactorSession) TransferOwnership 

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

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(_newOwner address) returns()

type Pausable 

type Pausable struct {
	PausableCaller     // Read-only binding to the contract
	PausableTransactor // Write-only binding to the contract
	PausableFilterer   // Log filterer for contract events
}

Pausable is an auto generated Go binding around an Ethereum contract.

func NewPausable 

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

NewPausable creates a new instance of Pausable, bound to a specific deployed contract.

type PausableCaller 

type PausableCaller struct {
	// contains filtered or unexported fields
}

PausableCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewPausableCaller 

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

NewPausableCaller creates a new read-only instance of Pausable, bound to a specific deployed contract.

func (*PausableCaller) Owner 

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

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*PausableCaller) Paused 

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

Paused is a free data retrieval call binding the contract method 0x5c975abb.

Solidity: function paused() constant returns(bool)

type PausableCallerRaw 

type PausableCallerRaw struct {
	Contract *PausableCaller // Generic read-only contract binding to access the raw methods on
}

PausableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*PausableCallerRaw) Call 

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

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type PausableCallerSession 

type PausableCallerSession struct {
	Contract *PausableCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts   // Call options to use throughout this session
}

PausableCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*PausableCallerSession) Owner 

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

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*PausableCallerSession) Paused 

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

Paused is a free data retrieval call binding the contract method 0x5c975abb.

Solidity: function paused() constant returns(bool)

type PausableFilterer 

type PausableFilterer struct {
	// contains filtered or unexported fields
}

PausableFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewPausableFilterer 

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

NewPausableFilterer creates a new log filterer instance of Pausable, bound to a specific deployed contract.

func (*PausableFilterer) FilterOwnershipRenounced 

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

FilterOwnershipRenounced is a free log retrieval operation binding the contract event 0xf8df31144d9c2f0f6b59d69b8b98abd5459d07f2742c4df920b25aae33c64820.

Solidity: e OwnershipRenounced(previousOwner indexed address)

func (*PausableFilterer) FilterOwnershipTransferred 

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

FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: e OwnershipTransferred(previousOwner indexed address, newOwner indexed address)

func (*PausableFilterer) FilterPause 

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

FilterPause is a free log retrieval operation binding the contract event 0x6985a02210a168e66602d3235cb6db0e70f92b3ba4d376a33c0f3d9434bff625.

Solidity: e Pause()

func (*PausableFilterer) FilterUnpause 

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

FilterUnpause is a free log retrieval operation binding the contract event 0x7805862f689e2f13df9f062ff482ad3ad112aca9e0847911ed832e158c525b33.

Solidity: e Unpause()

func (*PausableFilterer) WatchOwnershipRenounced 

func (_Pausable *PausableFilterer) WatchOwnershipRenounced(opts *bind.WatchOpts, sink chan<- *PausableOwnershipRenounced, previousOwner []common.Address) (event.Subscription, error)

WatchOwnershipRenounced is a free log subscription operation binding the contract event 0xf8df31144d9c2f0f6b59d69b8b98abd5459d07f2742c4df920b25aae33c64820.

Solidity: e OwnershipRenounced(previousOwner indexed address)

func (*PausableFilterer) WatchOwnershipTransferred 

func (_Pausable *PausableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *PausableOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: e OwnershipTransferred(previousOwner indexed address, newOwner indexed address)

func (*PausableFilterer) WatchPause 

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

WatchPause is a free log subscription operation binding the contract event 0x6985a02210a168e66602d3235cb6db0e70f92b3ba4d376a33c0f3d9434bff625.

Solidity: e Pause()

func (*PausableFilterer) WatchUnpause 

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

WatchUnpause is a free log subscription operation binding the contract event 0x7805862f689e2f13df9f062ff482ad3ad112aca9e0847911ed832e158c525b33.

Solidity: e Unpause()

type PausableOwnershipRenounced 

type PausableOwnershipRenounced struct {
	PreviousOwner common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

PausableOwnershipRenounced represents a OwnershipRenounced event raised by the Pausable contract.

type PausableOwnershipRenouncedIterator 

type PausableOwnershipRenouncedIterator struct {
	Event *PausableOwnershipRenounced // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

PausableOwnershipRenouncedIterator is returned from FilterOwnershipRenounced and is used to iterate over the raw logs and unpacked data for OwnershipRenounced events raised by the Pausable contract.

func (*PausableOwnershipRenouncedIterator) Close 

func (it *PausableOwnershipRenouncedIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*PausableOwnershipRenouncedIterator) Error 

func (it *PausableOwnershipRenouncedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*PausableOwnershipRenouncedIterator) Next 

func (it *PausableOwnershipRenouncedIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type PausableOwnershipTransferred 

type PausableOwnershipTransferred struct {
	PreviousOwner common.Address
	NewOwner      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

PausableOwnershipTransferred represents a OwnershipTransferred event raised by the Pausable contract.

type PausableOwnershipTransferredIterator 

type PausableOwnershipTransferredIterator struct {
	Event *PausableOwnershipTransferred // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

PausableOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Pausable contract.

func (*PausableOwnershipTransferredIterator) Close 

func (it *PausableOwnershipTransferredIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*PausableOwnershipTransferredIterator) Error 

func (it *PausableOwnershipTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*PausableOwnershipTransferredIterator) Next 

func (it *PausableOwnershipTransferredIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type PausablePause 

type PausablePause struct {
	Raw types.Log // Blockchain specific contextual infos
}

PausablePause represents a Pause event raised by the Pausable contract.

type PausablePauseIterator 

type PausablePauseIterator struct {
	Event *PausablePause // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

PausablePauseIterator is returned from FilterPause and is used to iterate over the raw logs and unpacked data for Pause events raised by the Pausable contract.

func (*PausablePauseIterator) Close 

func (it *PausablePauseIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*PausablePauseIterator) Error 

func (it *PausablePauseIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*PausablePauseIterator) Next 

func (it *PausablePauseIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type PausableRaw 

type PausableRaw struct {
	Contract *Pausable // Generic contract binding to access the raw methods on
}

PausableRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*PausableRaw) Call 

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

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*PausableRaw) Transact 

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

Transact invokes the (paid) contract method with params as input values.

func (*PausableRaw) Transfer 

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

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type PausableSession 

type PausableSession struct {
	Contract     *Pausable         // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

PausableSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*PausableSession) Owner 

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

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*PausableSession) Pause 

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

Pause is a paid mutator transaction binding the contract method 0x8456cb59.

Solidity: function pause() returns()

func (*PausableSession) Paused 

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

Paused is a free data retrieval call binding the contract method 0x5c975abb.

Solidity: function paused() constant returns(bool)

func (*PausableSession) RenounceOwnership 

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

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*PausableSession) TransferOwnership 

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

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(_newOwner address) returns()

func (*PausableSession) Unpause 

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

Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a.

Solidity: function unpause() returns()

type PausableTransactor 

type PausableTransactor struct {
	// contains filtered or unexported fields
}

PausableTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewPausableTransactor 

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

NewPausableTransactor creates a new write-only instance of Pausable, bound to a specific deployed contract.

func (*PausableTransactor) Pause 

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

Pause is a paid mutator transaction binding the contract method 0x8456cb59.

Solidity: function pause() returns()

func (*PausableTransactor) RenounceOwnership 

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

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*PausableTransactor) TransferOwnership 

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

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(_newOwner address) returns()

func (*PausableTransactor) Unpause 

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

Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a.

Solidity: function unpause() returns()

type PausableTransactorRaw 

type PausableTransactorRaw struct {
	Contract *PausableTransactor // Generic write-only contract binding to access the raw methods on
}

PausableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*PausableTransactorRaw) Transact 

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

Transact invokes the (paid) contract method with params as input values.

func (*PausableTransactorRaw) Transfer 

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

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type PausableTransactorSession 

type PausableTransactorSession struct {
	Contract     *PausableTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
}

PausableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*PausableTransactorSession) Pause 

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

Pause is a paid mutator transaction binding the contract method 0x8456cb59.

Solidity: function pause() returns()

func (*PausableTransactorSession) RenounceOwnership 

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

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*PausableTransactorSession) TransferOwnership 

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

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(_newOwner address) returns()

func (*PausableTransactorSession) Unpause 

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

Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a.

Solidity: function unpause() returns()

type PausableUnpause 

type PausableUnpause struct {
	Raw types.Log // Blockchain specific contextual infos
}

PausableUnpause represents a Unpause event raised by the Pausable contract.

type PausableUnpauseIterator 

type PausableUnpauseIterator struct {
	Event *PausableUnpause // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

PausableUnpauseIterator is returned from FilterUnpause and is used to iterate over the raw logs and unpacked data for Unpause events raised by the Pausable contract.

func (*PausableUnpauseIterator) Close 

func (it *PausableUnpauseIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*PausableUnpauseIterator) Error 

func (it *PausableUnpauseIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*PausableUnpauseIterator) Next 

func (it *PausableUnpauseIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type Room 

type Room struct {
	RoomCaller     // Read-only binding to the contract
	RoomTransactor // Write-only binding to the contract
	RoomFilterer   // Log filterer for contract events
}

Room is an auto generated Go binding around an Ethereum contract.

func NewRoom 

func NewRoom(address common.Address, backend bind.ContractBackend) (*Room, error)

NewRoom creates a new instance of Room, bound to a specific deployed contract.

type RoomActivate 

type RoomActivate struct {
	Sender common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

RoomActivate represents a Activate event raised by the Room contract.

type RoomActivateIterator 

type RoomActivateIterator struct {
	Event *RoomActivate // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

RoomActivateIterator is returned from FilterActivate and is used to iterate over the raw logs and unpacked data for Activate events raised by the Room contract.

func (*RoomActivateIterator) Close 

func (it *RoomActivateIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*RoomActivateIterator) Error 

func (it *RoomActivateIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RoomActivateIterator) Next 

func (it *RoomActivateIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type RoomCaller 

type RoomCaller struct {
	// contains filtered or unexported fields
}

RoomCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewRoomCaller 

func NewRoomCaller(address common.Address, caller bind.ContractCaller) (*RoomCaller, error)

NewRoomCaller creates a new read-only instance of Room, bound to a specific deployed contract.

func (*RoomCaller) Active 

func (_Room *RoomCaller) Active(opts *bind.CallOpts) (bool, error)

Active is a free data retrieval call binding the contract method 0x02fb0c5e.

Solidity: function active() constant returns(bool)

func (*RoomCaller) Owner 

func (_Room *RoomCaller) Owner(opts *bind.CallOpts) (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*RoomCaller) Paused 

func (_Room *RoomCaller) Paused(opts *bind.CallOpts) (bool, error)

Paused is a free data retrieval call binding the contract method 0x5c975abb.

Solidity: function paused() constant returns(bool)

func (*RoomCaller) RewardSent 

func (_Room *RoomCaller) RewardSent(opts *bind.CallOpts, arg0 *big.Int) (bool, error)

RewardSent is a free data retrieval call binding the contract method 0x8f134025.

Solidity: function rewardSent( uint256) constant returns(bool)

type RoomCallerRaw 

type RoomCallerRaw struct {
	Contract *RoomCaller // Generic read-only contract binding to access the raw methods on
}

RoomCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*RoomCallerRaw) Call 

func (_Room *RoomCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type RoomCallerSession 

type RoomCallerSession struct {
	Contract *RoomCaller   // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts // Call options to use throughout this session
}

RoomCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*RoomCallerSession) Active 

func (_Room *RoomCallerSession) Active() (bool, error)

Active is a free data retrieval call binding the contract method 0x02fb0c5e.

Solidity: function active() constant returns(bool)

func (*RoomCallerSession) Owner 

func (_Room *RoomCallerSession) Owner() (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*RoomCallerSession) Paused 

func (_Room *RoomCallerSession) Paused() (bool, error)

Paused is a free data retrieval call binding the contract method 0x5c975abb.

Solidity: function paused() constant returns(bool)

func (*RoomCallerSession) RewardSent 

func (_Room *RoomCallerSession) RewardSent(arg0 *big.Int) (bool, error)

RewardSent is a free data retrieval call binding the contract method 0x8f134025.

Solidity: function rewardSent( uint256) constant returns(bool)

type RoomDeactivate 

type RoomDeactivate struct {
	Sender common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

RoomDeactivate represents a Deactivate event raised by the Room contract.

type RoomDeactivateIterator 

type RoomDeactivateIterator struct {
	Event *RoomDeactivate // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

RoomDeactivateIterator is returned from FilterDeactivate and is used to iterate over the raw logs and unpacked data for Deactivate events raised by the Room contract.

func (*RoomDeactivateIterator) Close 

func (it *RoomDeactivateIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*RoomDeactivateIterator) Error 

func (it *RoomDeactivateIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RoomDeactivateIterator) Next 

func (it *RoomDeactivateIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type RoomDeposited 

type RoomDeposited struct {
	Depositor      common.Address
	DepositedValue *big.Int
	Raw            types.Log // Blockchain specific contextual infos
}

RoomDeposited represents a Deposited event raised by the Room contract.

type RoomDepositedIterator 

type RoomDepositedIterator struct {
	Event *RoomDeposited // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

RoomDepositedIterator is returned from FilterDeposited and is used to iterate over the raw logs and unpacked data for Deposited events raised by the Room contract.

func (*RoomDepositedIterator) Close 

func (it *RoomDepositedIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*RoomDepositedIterator) Error 

func (it *RoomDepositedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RoomDepositedIterator) Next 

func (it *RoomDepositedIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type RoomFactory 

type RoomFactory struct {
	RoomFactoryCaller     // Read-only binding to the contract
	RoomFactoryTransactor // Write-only binding to the contract
	RoomFactoryFilterer   // Log filterer for contract events
}

RoomFactory is an auto generated Go binding around an Ethereum contract.

func NewRoomFactory 

func NewRoomFactory(address common.Address, backend bind.ContractBackend) (*RoomFactory, error)

NewRoomFactory creates a new instance of RoomFactory, bound to a specific deployed contract.

type RoomFactoryCaller 

type RoomFactoryCaller struct {
	// contains filtered or unexported fields
}

RoomFactoryCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewRoomFactoryCaller 

func NewRoomFactoryCaller(address common.Address, caller bind.ContractCaller) (*RoomFactoryCaller, error)

NewRoomFactoryCaller creates a new read-only instance of RoomFactory, bound to a specific deployed contract.

func (*RoomFactoryCaller) Owner 

func (_RoomFactory *RoomFactoryCaller) Owner(opts *bind.CallOpts) (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*RoomFactoryCaller) Paused 

func (_RoomFactory *RoomFactoryCaller) Paused(opts *bind.CallOpts) (bool, error)

Paused is a free data retrieval call binding the contract method 0x5c975abb.

Solidity: function paused() constant returns(bool)

type RoomFactoryCallerRaw 

type RoomFactoryCallerRaw struct {
	Contract *RoomFactoryCaller // Generic read-only contract binding to access the raw methods on
}

RoomFactoryCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*RoomFactoryCallerRaw) Call 

func (_RoomFactory *RoomFactoryCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type RoomFactoryCallerSession 

type RoomFactoryCallerSession struct {
	Contract *RoomFactoryCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts      // Call options to use throughout this session
}

RoomFactoryCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*RoomFactoryCallerSession) Owner 

func (_RoomFactory *RoomFactoryCallerSession) Owner() (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*RoomFactoryCallerSession) Paused 

func (_RoomFactory *RoomFactoryCallerSession) Paused() (bool, error)

Paused is a free data retrieval call binding the contract method 0x5c975abb.

Solidity: function paused() constant returns(bool)

type RoomFactoryFilterer 

type RoomFactoryFilterer struct {
	// contains filtered or unexported fields
}

RoomFactoryFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewRoomFactoryFilterer 

func NewRoomFactoryFilterer(address common.Address, filterer bind.ContractFilterer) (*RoomFactoryFilterer, error)

NewRoomFactoryFilterer creates a new log filterer instance of RoomFactory, bound to a specific deployed contract.

func (*RoomFactoryFilterer) FilterOwnershipRenounced 

func (_RoomFactory *RoomFactoryFilterer) FilterOwnershipRenounced(opts *bind.FilterOpts, previousOwner []common.Address) (*RoomFactoryOwnershipRenouncedIterator, error)

FilterOwnershipRenounced is a free log retrieval operation binding the contract event 0xf8df31144d9c2f0f6b59d69b8b98abd5459d07f2742c4df920b25aae33c64820.

Solidity: e OwnershipRenounced(previousOwner indexed address)

func (*RoomFactoryFilterer) FilterOwnershipTransferred 

func (_RoomFactory *RoomFactoryFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*RoomFactoryOwnershipTransferredIterator, error)

FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: e OwnershipTransferred(previousOwner indexed address, newOwner indexed address)

func (*RoomFactoryFilterer) FilterPause 

func (_RoomFactory *RoomFactoryFilterer) FilterPause(opts *bind.FilterOpts) (*RoomFactoryPauseIterator, error)

FilterPause is a free log retrieval operation binding the contract event 0x6985a02210a168e66602d3235cb6db0e70f92b3ba4d376a33c0f3d9434bff625.

Solidity: e Pause()

func (*RoomFactoryFilterer) FilterRoomCreated 

func (_RoomFactory *RoomFactoryFilterer) FilterRoomCreated(opts *bind.FilterOpts, _creator []common.Address) (*RoomFactoryRoomCreatedIterator, error)

FilterRoomCreated is a free log retrieval operation binding the contract event 0x6849f7a409ad97d39c5ffa074bf765330bf1a574da99d4c4831196ecd77ea8da.

Solidity: e RoomCreated(_creator indexed address, _room address, _depositedValue uint256)

func (*RoomFactoryFilterer) FilterUnpause 

func (_RoomFactory *RoomFactoryFilterer) FilterUnpause(opts *bind.FilterOpts) (*RoomFactoryUnpauseIterator, error)

FilterUnpause is a free log retrieval operation binding the contract event 0x7805862f689e2f13df9f062ff482ad3ad112aca9e0847911ed832e158c525b33.

Solidity: e Unpause()

func (*RoomFactoryFilterer) WatchOwnershipRenounced 

func (_RoomFactory *RoomFactoryFilterer) WatchOwnershipRenounced(opts *bind.WatchOpts, sink chan<- *RoomFactoryOwnershipRenounced, previousOwner []common.Address) (event.Subscription, error)

WatchOwnershipRenounced is a free log subscription operation binding the contract event 0xf8df31144d9c2f0f6b59d69b8b98abd5459d07f2742c4df920b25aae33c64820.

Solidity: e OwnershipRenounced(previousOwner indexed address)

func (*RoomFactoryFilterer) WatchOwnershipTransferred 

func (_RoomFactory *RoomFactoryFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *RoomFactoryOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: e OwnershipTransferred(previousOwner indexed address, newOwner indexed address)

func (*RoomFactoryFilterer) WatchPause 

func (_RoomFactory *RoomFactoryFilterer) WatchPause(opts *bind.WatchOpts, sink chan<- *RoomFactoryPause) (event.Subscription, error)

WatchPause is a free log subscription operation binding the contract event 0x6985a02210a168e66602d3235cb6db0e70f92b3ba4d376a33c0f3d9434bff625.

Solidity: e Pause()

func (*RoomFactoryFilterer) WatchRoomCreated 

func (_RoomFactory *RoomFactoryFilterer) WatchRoomCreated(opts *bind.WatchOpts, sink chan<- *RoomFactoryRoomCreated, _creator []common.Address) (event.Subscription, error)

WatchRoomCreated is a free log subscription operation binding the contract event 0x6849f7a409ad97d39c5ffa074bf765330bf1a574da99d4c4831196ecd77ea8da.

Solidity: e RoomCreated(_creator indexed address, _room address, _depositedValue uint256)

func (*RoomFactoryFilterer) WatchUnpause 

func (_RoomFactory *RoomFactoryFilterer) WatchUnpause(opts *bind.WatchOpts, sink chan<- *RoomFactoryUnpause) (event.Subscription, error)

WatchUnpause is a free log subscription operation binding the contract event 0x7805862f689e2f13df9f062ff482ad3ad112aca9e0847911ed832e158c525b33.

Solidity: e Unpause()

type RoomFactoryOwnershipRenounced 

type RoomFactoryOwnershipRenounced struct {
	PreviousOwner common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

RoomFactoryOwnershipRenounced represents a OwnershipRenounced event raised by the RoomFactory contract.

type RoomFactoryOwnershipRenouncedIterator 

type RoomFactoryOwnershipRenouncedIterator struct {
	Event *RoomFactoryOwnershipRenounced // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

RoomFactoryOwnershipRenouncedIterator is returned from FilterOwnershipRenounced and is used to iterate over the raw logs and unpacked data for OwnershipRenounced events raised by the RoomFactory contract.

func (*RoomFactoryOwnershipRenouncedIterator) Close 

func (it *RoomFactoryOwnershipRenouncedIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*RoomFactoryOwnershipRenouncedIterator) Error 

func (it *RoomFactoryOwnershipRenouncedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RoomFactoryOwnershipRenouncedIterator) Next 

func (it *RoomFactoryOwnershipRenouncedIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type RoomFactoryOwnershipTransferred 

type RoomFactoryOwnershipTransferred struct {
	PreviousOwner common.Address
	NewOwner      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

RoomFactoryOwnershipTransferred represents a OwnershipTransferred event raised by the RoomFactory contract.

type RoomFactoryOwnershipTransferredIterator 

type RoomFactoryOwnershipTransferredIterator struct {
	Event *RoomFactoryOwnershipTransferred // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

RoomFactoryOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the RoomFactory contract.

func (*RoomFactoryOwnershipTransferredIterator) Close 

func (it *RoomFactoryOwnershipTransferredIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*RoomFactoryOwnershipTransferredIterator) Error 

func (it *RoomFactoryOwnershipTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RoomFactoryOwnershipTransferredIterator) Next 

func (it *RoomFactoryOwnershipTransferredIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type RoomFactoryPause 

type RoomFactoryPause struct {
	Raw types.Log // Blockchain specific contextual infos
}

RoomFactoryPause represents a Pause event raised by the RoomFactory contract.

type RoomFactoryPauseIterator 

type RoomFactoryPauseIterator struct {
	Event *RoomFactoryPause // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

RoomFactoryPauseIterator is returned from FilterPause and is used to iterate over the raw logs and unpacked data for Pause events raised by the RoomFactory contract.

func (*RoomFactoryPauseIterator) Close 

func (it *RoomFactoryPauseIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*RoomFactoryPauseIterator) Error 

func (it *RoomFactoryPauseIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RoomFactoryPauseIterator) Next 

func (it *RoomFactoryPauseIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type RoomFactoryRaw 

type RoomFactoryRaw struct {
	Contract *RoomFactory // Generic contract binding to access the raw methods on
}

RoomFactoryRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*RoomFactoryRaw) Call 

func (_RoomFactory *RoomFactoryRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*RoomFactoryRaw) Transact 

func (_RoomFactory *RoomFactoryRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*RoomFactoryRaw) Transfer 

func (_RoomFactory *RoomFactoryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type RoomFactoryRoomCreated 

type RoomFactoryRoomCreated struct {
	Creator        common.Address
	Room           common.Address
	DepositedValue *big.Int
	Raw            types.Log // Blockchain specific contextual infos
}

RoomFactoryRoomCreated represents a RoomCreated event raised by the RoomFactory contract.

type RoomFactoryRoomCreatedIterator 

type RoomFactoryRoomCreatedIterator struct {
	Event *RoomFactoryRoomCreated // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

RoomFactoryRoomCreatedIterator is returned from FilterRoomCreated and is used to iterate over the raw logs and unpacked data for RoomCreated events raised by the RoomFactory contract.

func (*RoomFactoryRoomCreatedIterator) Close 

func (it *RoomFactoryRoomCreatedIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*RoomFactoryRoomCreatedIterator) Error 

func (it *RoomFactoryRoomCreatedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RoomFactoryRoomCreatedIterator) Next 

func (it *RoomFactoryRoomCreatedIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type RoomFactorySession 

type RoomFactorySession struct {
	Contract     *RoomFactory      // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

RoomFactorySession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*RoomFactorySession) CreateRoom 

func (_RoomFactory *RoomFactorySession) CreateRoom() (*types.Transaction, error)

CreateRoom is a paid mutator transaction binding the contract method 0x3be272aa.

Solidity: function createRoom() returns()

func (*RoomFactorySession) Destroy 

func (_RoomFactory *RoomFactorySession) Destroy() (*types.Transaction, error)

Destroy is a paid mutator transaction binding the contract method 0x83197ef0.

Solidity: function destroy() returns()

func (*RoomFactorySession) DestroyAndSend 

func (_RoomFactory *RoomFactorySession) DestroyAndSend(_recipient common.Address) (*types.Transaction, error)

DestroyAndSend is a paid mutator transaction binding the contract method 0xf5074f41.

Solidity: function destroyAndSend(_recipient address) returns()

func (*RoomFactorySession) Owner 

func (_RoomFactory *RoomFactorySession) Owner() (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*RoomFactorySession) Pause 

func (_RoomFactory *RoomFactorySession) Pause() (*types.Transaction, error)

Pause is a paid mutator transaction binding the contract method 0x8456cb59.

Solidity: function pause() returns()

func (*RoomFactorySession) Paused 

func (_RoomFactory *RoomFactorySession) Paused() (bool, error)

Paused is a free data retrieval call binding the contract method 0x5c975abb.

Solidity: function paused() constant returns(bool)

func (*RoomFactorySession) RenounceOwnership 

func (_RoomFactory *RoomFactorySession) RenounceOwnership() (*types.Transaction, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*RoomFactorySession) TransferOwnership 

func (_RoomFactory *RoomFactorySession) TransferOwnership(_newOwner common.Address) (*types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(_newOwner address) returns()

func (*RoomFactorySession) Unpause 

func (_RoomFactory *RoomFactorySession) Unpause() (*types.Transaction, error)

Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a.

Solidity: function unpause() returns()

type RoomFactoryTransactor 

type RoomFactoryTransactor struct {
	// contains filtered or unexported fields
}

RoomFactoryTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewRoomFactoryTransactor 

func NewRoomFactoryTransactor(address common.Address, transactor bind.ContractTransactor) (*RoomFactoryTransactor, error)

NewRoomFactoryTransactor creates a new write-only instance of RoomFactory, bound to a specific deployed contract.

func (*RoomFactoryTransactor) CreateRoom 

func (_RoomFactory *RoomFactoryTransactor) CreateRoom(opts *bind.TransactOpts) (*types.Transaction, error)

CreateRoom is a paid mutator transaction binding the contract method 0x3be272aa.

Solidity: function createRoom() returns()

func (*RoomFactoryTransactor) Destroy 

func (_RoomFactory *RoomFactoryTransactor) Destroy(opts *bind.TransactOpts) (*types.Transaction, error)

Destroy is a paid mutator transaction binding the contract method 0x83197ef0.

Solidity: function destroy() returns()

func (*RoomFactoryTransactor) DestroyAndSend 

func (_RoomFactory *RoomFactoryTransactor) DestroyAndSend(opts *bind.TransactOpts, _recipient common.Address) (*types.Transaction, error)

DestroyAndSend is a paid mutator transaction binding the contract method 0xf5074f41.

Solidity: function destroyAndSend(_recipient address) returns()

func (*RoomFactoryTransactor) Pause 

func (_RoomFactory *RoomFactoryTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error)

Pause is a paid mutator transaction binding the contract method 0x8456cb59.

Solidity: function pause() returns()

func (*RoomFactoryTransactor) RenounceOwnership 

func (_RoomFactory *RoomFactoryTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*RoomFactoryTransactor) TransferOwnership 

func (_RoomFactory *RoomFactoryTransactor) TransferOwnership(opts *bind.TransactOpts, _newOwner common.Address) (*types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(_newOwner address) returns()

func (*RoomFactoryTransactor) Unpause 

func (_RoomFactory *RoomFactoryTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error)

Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a.

Solidity: function unpause() returns()

type RoomFactoryTransactorRaw 

type RoomFactoryTransactorRaw struct {
	Contract *RoomFactoryTransactor // Generic write-only contract binding to access the raw methods on
}

RoomFactoryTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*RoomFactoryTransactorRaw) Transact 

func (_RoomFactory *RoomFactoryTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*RoomFactoryTransactorRaw) Transfer 

func (_RoomFactory *RoomFactoryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type RoomFactoryTransactorSession 

type RoomFactoryTransactorSession struct {
	Contract     *RoomFactoryTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts      // Transaction auth options to use throughout this session
}

RoomFactoryTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*RoomFactoryTransactorSession) CreateRoom 

func (_RoomFactory *RoomFactoryTransactorSession) CreateRoom() (*types.Transaction, error)

CreateRoom is a paid mutator transaction binding the contract method 0x3be272aa.

Solidity: function createRoom() returns()

func (*RoomFactoryTransactorSession) Destroy 

func (_RoomFactory *RoomFactoryTransactorSession) Destroy() (*types.Transaction, error)

Destroy is a paid mutator transaction binding the contract method 0x83197ef0.

Solidity: function destroy() returns()

func (*RoomFactoryTransactorSession) DestroyAndSend 

func (_RoomFactory *RoomFactoryTransactorSession) DestroyAndSend(_recipient common.Address) (*types.Transaction, error)

DestroyAndSend is a paid mutator transaction binding the contract method 0xf5074f41.

Solidity: function destroyAndSend(_recipient address) returns()

func (*RoomFactoryTransactorSession) Pause 

func (_RoomFactory *RoomFactoryTransactorSession) Pause() (*types.Transaction, error)

Pause is a paid mutator transaction binding the contract method 0x8456cb59.

Solidity: function pause() returns()

func (*RoomFactoryTransactorSession) RenounceOwnership 

func (_RoomFactory *RoomFactoryTransactorSession) RenounceOwnership() (*types.Transaction, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*RoomFactoryTransactorSession) TransferOwnership 

func (_RoomFactory *RoomFactoryTransactorSession) TransferOwnership(_newOwner common.Address) (*types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(_newOwner address) returns()

func (*RoomFactoryTransactorSession) Unpause 

func (_RoomFactory *RoomFactoryTransactorSession) Unpause() (*types.Transaction, error)

Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a.

Solidity: function unpause() returns()

type RoomFactoryUnpause 

type RoomFactoryUnpause struct {
	Raw types.Log // Blockchain specific contextual infos
}

RoomFactoryUnpause represents a Unpause event raised by the RoomFactory contract.

type RoomFactoryUnpauseIterator 

type RoomFactoryUnpauseIterator struct {
	Event *RoomFactoryUnpause // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

RoomFactoryUnpauseIterator is returned from FilterUnpause and is used to iterate over the raw logs and unpacked data for Unpause events raised by the RoomFactory contract.

func (*RoomFactoryUnpauseIterator) Close 

func (it *RoomFactoryUnpauseIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*RoomFactoryUnpauseIterator) Error 

func (it *RoomFactoryUnpauseIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RoomFactoryUnpauseIterator) Next 

func (it *RoomFactoryUnpauseIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type RoomFilterer 

type RoomFilterer struct {
	// contains filtered or unexported fields
}

RoomFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewRoomFilterer 

func NewRoomFilterer(address common.Address, filterer bind.ContractFilterer) (*RoomFilterer, error)

NewRoomFilterer creates a new log filterer instance of Room, bound to a specific deployed contract.

func (*RoomFilterer) FilterActivate 

func (_Room *RoomFilterer) FilterActivate(opts *bind.FilterOpts, _sender []common.Address) (*RoomActivateIterator, error)

FilterActivate is a free log retrieval operation binding the contract event 0xf7e9fe69e1d05372bc855b295bc4c34a1a0a5882164dd2b26df30a26c1c8ba15.

Solidity: e Activate(_sender indexed address)

func (*RoomFilterer) FilterDeactivate 

func (_Room *RoomFilterer) FilterDeactivate(opts *bind.FilterOpts, _sender []common.Address) (*RoomDeactivateIterator, error)

FilterDeactivate is a free log retrieval operation binding the contract event 0x238ce44d0fada9e1348f183a8436996fb52b4c41a9cbf3af6e2dee00fcb80a9c.

Solidity: e Deactivate(_sender indexed address)

func (*RoomFilterer) FilterDeposited 

func (_Room *RoomFilterer) FilterDeposited(opts *bind.FilterOpts, _depositor []common.Address) (*RoomDepositedIterator, error)

FilterDeposited is a free log retrieval operation binding the contract event 0x2da466a7b24304f47e87fa2e1e5a81b9831ce54fec19055ce277ca2f39ba42c4.

Solidity: e Deposited(_depositor indexed address, _depositedValue uint256)

func (*RoomFilterer) FilterOwnershipRenounced 

func (_Room *RoomFilterer) FilterOwnershipRenounced(opts *bind.FilterOpts, previousOwner []common.Address) (*RoomOwnershipRenouncedIterator, error)

FilterOwnershipRenounced is a free log retrieval operation binding the contract event 0xf8df31144d9c2f0f6b59d69b8b98abd5459d07f2742c4df920b25aae33c64820.

Solidity: e OwnershipRenounced(previousOwner indexed address)

func (*RoomFilterer) FilterOwnershipTransferred 

func (_Room *RoomFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*RoomOwnershipTransferredIterator, error)

FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: e OwnershipTransferred(previousOwner indexed address, newOwner indexed address)

func (*RoomFilterer) FilterPause 

func (_Room *RoomFilterer) FilterPause(opts *bind.FilterOpts) (*RoomPauseIterator, error)

FilterPause is a free log retrieval operation binding the contract event 0x6985a02210a168e66602d3235cb6db0e70f92b3ba4d376a33c0f3d9434bff625.

Solidity: e Pause()

func (*RoomFilterer) FilterRefundedToOwner 

func (_Room *RoomFilterer) FilterRefundedToOwner(opts *bind.FilterOpts, _dest []common.Address) (*RoomRefundedToOwnerIterator, error)

FilterRefundedToOwner is a free log retrieval operation binding the contract event 0xa9304f0ac97f820b11d5a66f29245fb1e76b1f1f93f46a84a71682e69d095e80.

Solidity: e RefundedToOwner(_dest indexed address, _refundedBalance uint256)

func (*RoomFilterer) FilterRewardSent 

func (_Room *RoomFilterer) FilterRewardSent(opts *bind.FilterOpts, _dest []common.Address) (*RoomRewardSentIterator, error)

FilterRewardSent is a free log retrieval operation binding the contract event 0x6379339f0ae63e95e65fad18ca2a7ec4e7e3f05f3cc5f7079f4d8da8cec34faa.

Solidity: e RewardSent(_dest indexed address, _reward uint256, _id uint256)

func (*RoomFilterer) FilterUnpause 

func (_Room *RoomFilterer) FilterUnpause(opts *bind.FilterOpts) (*RoomUnpauseIterator, error)

FilterUnpause is a free log retrieval operation binding the contract event 0x7805862f689e2f13df9f062ff482ad3ad112aca9e0847911ed832e158c525b33.

Solidity: e Unpause()

func (*RoomFilterer) WatchActivate 

func (_Room *RoomFilterer) WatchActivate(opts *bind.WatchOpts, sink chan<- *RoomActivate, _sender []common.Address) (event.Subscription, error)

WatchActivate is a free log subscription operation binding the contract event 0xf7e9fe69e1d05372bc855b295bc4c34a1a0a5882164dd2b26df30a26c1c8ba15.

Solidity: e Activate(_sender indexed address)

func (*RoomFilterer) WatchDeactivate 

func (_Room *RoomFilterer) WatchDeactivate(opts *bind.WatchOpts, sink chan<- *RoomDeactivate, _sender []common.Address) (event.Subscription, error)

WatchDeactivate is a free log subscription operation binding the contract event 0x238ce44d0fada9e1348f183a8436996fb52b4c41a9cbf3af6e2dee00fcb80a9c.

Solidity: e Deactivate(_sender indexed address)

func (*RoomFilterer) WatchDeposited 

func (_Room *RoomFilterer) WatchDeposited(opts *bind.WatchOpts, sink chan<- *RoomDeposited, _depositor []common.Address) (event.Subscription, error)

WatchDeposited is a free log subscription operation binding the contract event 0x2da466a7b24304f47e87fa2e1e5a81b9831ce54fec19055ce277ca2f39ba42c4.

Solidity: e Deposited(_depositor indexed address, _depositedValue uint256)

func (*RoomFilterer) WatchOwnershipRenounced 

func (_Room *RoomFilterer) WatchOwnershipRenounced(opts *bind.WatchOpts, sink chan<- *RoomOwnershipRenounced, previousOwner []common.Address) (event.Subscription, error)

WatchOwnershipRenounced is a free log subscription operation binding the contract event 0xf8df31144d9c2f0f6b59d69b8b98abd5459d07f2742c4df920b25aae33c64820.

Solidity: e OwnershipRenounced(previousOwner indexed address)

func (*RoomFilterer) WatchOwnershipTransferred 

func (_Room *RoomFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *RoomOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: e OwnershipTransferred(previousOwner indexed address, newOwner indexed address)

func (*RoomFilterer) WatchPause 

func (_Room *RoomFilterer) WatchPause(opts *bind.WatchOpts, sink chan<- *RoomPause) (event.Subscription, error)

WatchPause is a free log subscription operation binding the contract event 0x6985a02210a168e66602d3235cb6db0e70f92b3ba4d376a33c0f3d9434bff625.

Solidity: e Pause()

func (*RoomFilterer) WatchRefundedToOwner 

func (_Room *RoomFilterer) WatchRefundedToOwner(opts *bind.WatchOpts, sink chan<- *RoomRefundedToOwner, _dest []common.Address) (event.Subscription, error)

WatchRefundedToOwner is a free log subscription operation binding the contract event 0xa9304f0ac97f820b11d5a66f29245fb1e76b1f1f93f46a84a71682e69d095e80.

Solidity: e RefundedToOwner(_dest indexed address, _refundedBalance uint256)

func (*RoomFilterer) WatchRewardSent 

func (_Room *RoomFilterer) WatchRewardSent(opts *bind.WatchOpts, sink chan<- *RoomRewardSent, _dest []common.Address) (event.Subscription, error)

WatchRewardSent is a free log subscription operation binding the contract event 0x6379339f0ae63e95e65fad18ca2a7ec4e7e3f05f3cc5f7079f4d8da8cec34faa.

Solidity: e RewardSent(_dest indexed address, _reward uint256, _id uint256)

func (*RoomFilterer) WatchUnpause 

func (_Room *RoomFilterer) WatchUnpause(opts *bind.WatchOpts, sink chan<- *RoomUnpause) (event.Subscription, error)

WatchUnpause is a free log subscription operation binding the contract event 0x7805862f689e2f13df9f062ff482ad3ad112aca9e0847911ed832e158c525b33.

Solidity: e Unpause()

type RoomOwnershipRenounced 

type RoomOwnershipRenounced struct {
	PreviousOwner common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

RoomOwnershipRenounced represents a OwnershipRenounced event raised by the Room contract.

type RoomOwnershipRenouncedIterator 

type RoomOwnershipRenouncedIterator struct {
	Event *RoomOwnershipRenounced // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

RoomOwnershipRenouncedIterator is returned from FilterOwnershipRenounced and is used to iterate over the raw logs and unpacked data for OwnershipRenounced events raised by the Room contract.

func (*RoomOwnershipRenouncedIterator) Close 

func (it *RoomOwnershipRenouncedIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*RoomOwnershipRenouncedIterator) Error 

func (it *RoomOwnershipRenouncedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RoomOwnershipRenouncedIterator) Next 

func (it *RoomOwnershipRenouncedIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type RoomOwnershipTransferred 

type RoomOwnershipTransferred struct {
	PreviousOwner common.Address
	NewOwner      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

RoomOwnershipTransferred represents a OwnershipTransferred event raised by the Room contract.

type RoomOwnershipTransferredIterator 

type RoomOwnershipTransferredIterator struct {
	Event *RoomOwnershipTransferred // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

RoomOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Room contract.

func (*RoomOwnershipTransferredIterator) Close 

func (it *RoomOwnershipTransferredIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*RoomOwnershipTransferredIterator) Error 

func (it *RoomOwnershipTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RoomOwnershipTransferredIterator) Next 

func (it *RoomOwnershipTransferredIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type RoomPause 

type RoomPause struct {
	Raw types.Log // Blockchain specific contextual infos
}

RoomPause represents a Pause event raised by the Room contract.

type RoomPauseIterator 

type RoomPauseIterator struct {
	Event *RoomPause // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

RoomPauseIterator is returned from FilterPause and is used to iterate over the raw logs and unpacked data for Pause events raised by the Room contract.

func (*RoomPauseIterator) Close 

func (it *RoomPauseIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*RoomPauseIterator) Error 

func (it *RoomPauseIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RoomPauseIterator) Next 

func (it *RoomPauseIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type RoomRaw 

type RoomRaw struct {
	Contract *Room // Generic contract binding to access the raw methods on
}

RoomRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*RoomRaw) Call 

func (_Room *RoomRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*RoomRaw) Transact 

func (_Room *RoomRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*RoomRaw) Transfer 

func (_Room *RoomRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type RoomRefundedToOwner 

type RoomRefundedToOwner struct {
	Dest            common.Address
	RefundedBalance *big.Int
	Raw             types.Log // Blockchain specific contextual infos
}

RoomRefundedToOwner represents a RefundedToOwner event raised by the Room contract.

type RoomRefundedToOwnerIterator 

type RoomRefundedToOwnerIterator struct {
	Event *RoomRefundedToOwner // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

RoomRefundedToOwnerIterator is returned from FilterRefundedToOwner and is used to iterate over the raw logs and unpacked data for RefundedToOwner events raised by the Room contract.

func (*RoomRefundedToOwnerIterator) Close 

func (it *RoomRefundedToOwnerIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*RoomRefundedToOwnerIterator) Error 

func (it *RoomRefundedToOwnerIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RoomRefundedToOwnerIterator) Next 

func (it *RoomRefundedToOwnerIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type RoomRewardSent 

type RoomRewardSent struct {
	Dest   common.Address
	Reward *big.Int
	Id     *big.Int
	Raw    types.Log // Blockchain specific contextual infos
}

RoomRewardSent represents a RewardSent event raised by the Room contract.

type RoomRewardSentIterator 

type RoomRewardSentIterator struct {
	Event *RoomRewardSent // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

RoomRewardSentIterator is returned from FilterRewardSent and is used to iterate over the raw logs and unpacked data for RewardSent events raised by the Room contract.

func (*RoomRewardSentIterator) Close 

func (it *RoomRewardSentIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*RoomRewardSentIterator) Error 

func (it *RoomRewardSentIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RoomRewardSentIterator) Next 

func (it *RoomRewardSentIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type RoomSession 

type RoomSession struct {
	Contract     *Room             // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

RoomSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*RoomSession) Activate 

func (_Room *RoomSession) Activate() (*types.Transaction, error)

Activate is a paid mutator transaction binding the contract method 0x0f15f4c0.

Solidity: function activate() returns()

func (*RoomSession) Active 

func (_Room *RoomSession) Active() (bool, error)

Active is a free data retrieval call binding the contract method 0x02fb0c5e.

Solidity: function active() constant returns(bool)

func (*RoomSession) Deactivate 

func (_Room *RoomSession) Deactivate() (*types.Transaction, error)

Deactivate is a paid mutator transaction binding the contract method 0x51b42b00.

Solidity: function deactivate() returns()

func (*RoomSession) Deposit 

func (_Room *RoomSession) Deposit() (*types.Transaction, error)

Deposit is a paid mutator transaction binding the contract method 0xd0e30db0.

Solidity: function deposit() returns()

func (*RoomSession) Destroy 

func (_Room *RoomSession) Destroy() (*types.Transaction, error)

Destroy is a paid mutator transaction binding the contract method 0x83197ef0.

Solidity: function destroy() returns()

func (*RoomSession) DestroyAndSend 

func (_Room *RoomSession) DestroyAndSend(_recipient common.Address) (*types.Transaction, error)

DestroyAndSend is a paid mutator transaction binding the contract method 0xf5074f41.

Solidity: function destroyAndSend(_recipient address) returns()

func (*RoomSession) Owner 

func (_Room *RoomSession) Owner() (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*RoomSession) Pause 

func (_Room *RoomSession) Pause() (*types.Transaction, error)

Pause is a paid mutator transaction binding the contract method 0x8456cb59.

Solidity: function pause() returns()

func (*RoomSession) Paused 

func (_Room *RoomSession) Paused() (bool, error)

Paused is a free data retrieval call binding the contract method 0x5c975abb.

Solidity: function paused() constant returns(bool)

func (*RoomSession) RefundToOwner 

func (_Room *RoomSession) RefundToOwner() (*types.Transaction, error)

RefundToOwner is a paid mutator transaction binding the contract method 0x3e4e10d6.

Solidity: function refundToOwner() returns()

func (*RoomSession) RenounceOwnership 

func (_Room *RoomSession) RenounceOwnership() (*types.Transaction, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*RoomSession) RewardSent 

func (_Room *RoomSession) RewardSent(arg0 *big.Int) (bool, error)

RewardSent is a free data retrieval call binding the contract method 0x8f134025.

Solidity: function rewardSent( uint256) constant returns(bool)

func (*RoomSession) SendReward 

func (_Room *RoomSession) SendReward(_reward *big.Int, _dest common.Address, _id *big.Int) (*types.Transaction, error)

SendReward is a paid mutator transaction binding the contract method 0x2673bd74.

Solidity: function sendReward(_reward uint256, _dest address, _id uint256) returns()

func (*RoomSession) TransferOwnership 

func (_Room *RoomSession) TransferOwnership(_newOwner common.Address) (*types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(_newOwner address) returns()

func (*RoomSession) Unpause 

func (_Room *RoomSession) Unpause() (*types.Transaction, error)

Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a.

Solidity: function unpause() returns()

type RoomTransactor 

type RoomTransactor struct {
	// contains filtered or unexported fields
}

RoomTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewRoomTransactor 

func NewRoomTransactor(address common.Address, transactor bind.ContractTransactor) (*RoomTransactor, error)

NewRoomTransactor creates a new write-only instance of Room, bound to a specific deployed contract.

func (*RoomTransactor) Activate 

func (_Room *RoomTransactor) Activate(opts *bind.TransactOpts) (*types.Transaction, error)

Activate is a paid mutator transaction binding the contract method 0x0f15f4c0.

Solidity: function activate() returns()

func (*RoomTransactor) Deactivate 

func (_Room *RoomTransactor) Deactivate(opts *bind.TransactOpts) (*types.Transaction, error)

Deactivate is a paid mutator transaction binding the contract method 0x51b42b00.

Solidity: function deactivate() returns()

func (*RoomTransactor) Deposit 

func (_Room *RoomTransactor) Deposit(opts *bind.TransactOpts) (*types.Transaction, error)

Deposit is a paid mutator transaction binding the contract method 0xd0e30db0.

Solidity: function deposit() returns()

func (*RoomTransactor) Destroy 

func (_Room *RoomTransactor) Destroy(opts *bind.TransactOpts) (*types.Transaction, error)

Destroy is a paid mutator transaction binding the contract method 0x83197ef0.

Solidity: function destroy() returns()

func (*RoomTransactor) DestroyAndSend 

func (_Room *RoomTransactor) DestroyAndSend(opts *bind.TransactOpts, _recipient common.Address) (*types.Transaction, error)

DestroyAndSend is a paid mutator transaction binding the contract method 0xf5074f41.

Solidity: function destroyAndSend(_recipient address) returns()

func (*RoomTransactor) Pause 

func (_Room *RoomTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error)

Pause is a paid mutator transaction binding the contract method 0x8456cb59.

Solidity: function pause() returns()

func (*RoomTransactor) RefundToOwner 

func (_Room *RoomTransactor) RefundToOwner(opts *bind.TransactOpts) (*types.Transaction, error)

RefundToOwner is a paid mutator transaction binding the contract method 0x3e4e10d6.

Solidity: function refundToOwner() returns()

func (*RoomTransactor) RenounceOwnership 

func (_Room *RoomTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*RoomTransactor) SendReward 

func (_Room *RoomTransactor) SendReward(opts *bind.TransactOpts, _reward *big.Int, _dest common.Address, _id *big.Int) (*types.Transaction, error)

SendReward is a paid mutator transaction binding the contract method 0x2673bd74.

Solidity: function sendReward(_reward uint256, _dest address, _id uint256) returns()

func (*RoomTransactor) TransferOwnership 

func (_Room *RoomTransactor) TransferOwnership(opts *bind.TransactOpts, _newOwner common.Address) (*types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(_newOwner address) returns()

func (*RoomTransactor) Unpause 

func (_Room *RoomTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error)

Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a.

Solidity: function unpause() returns()

type RoomTransactorRaw 

type RoomTransactorRaw struct {
	Contract *RoomTransactor // Generic write-only contract binding to access the raw methods on
}

RoomTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*RoomTransactorRaw) Transact 

func (_Room *RoomTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*RoomTransactorRaw) Transfer 

func (_Room *RoomTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type RoomTransactorSession 

type RoomTransactorSession struct {
	Contract     *RoomTransactor   // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

RoomTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*RoomTransactorSession) Activate 

func (_Room *RoomTransactorSession) Activate() (*types.Transaction, error)

Activate is a paid mutator transaction binding the contract method 0x0f15f4c0.

Solidity: function activate() returns()

func (*RoomTransactorSession) Deactivate 

func (_Room *RoomTransactorSession) Deactivate() (*types.Transaction, error)

Deactivate is a paid mutator transaction binding the contract method 0x51b42b00.

Solidity: function deactivate() returns()

func (*RoomTransactorSession) Deposit 

func (_Room *RoomTransactorSession) Deposit() (*types.Transaction, error)

Deposit is a paid mutator transaction binding the contract method 0xd0e30db0.

Solidity: function deposit() returns()

func (*RoomTransactorSession) Destroy 

func (_Room *RoomTransactorSession) Destroy() (*types.Transaction, error)

Destroy is a paid mutator transaction binding the contract method 0x83197ef0.

Solidity: function destroy() returns()

func (*RoomTransactorSession) DestroyAndSend 

func (_Room *RoomTransactorSession) DestroyAndSend(_recipient common.Address) (*types.Transaction, error)

DestroyAndSend is a paid mutator transaction binding the contract method 0xf5074f41.

Solidity: function destroyAndSend(_recipient address) returns()

func (*RoomTransactorSession) Pause 

func (_Room *RoomTransactorSession) Pause() (*types.Transaction, error)

Pause is a paid mutator transaction binding the contract method 0x8456cb59.

Solidity: function pause() returns()

func (*RoomTransactorSession) RefundToOwner 

func (_Room *RoomTransactorSession) RefundToOwner() (*types.Transaction, error)

RefundToOwner is a paid mutator transaction binding the contract method 0x3e4e10d6.

Solidity: function refundToOwner() returns()

func (*RoomTransactorSession) RenounceOwnership 

func (_Room *RoomTransactorSession) RenounceOwnership() (*types.Transaction, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*RoomTransactorSession) SendReward 

func (_Room *RoomTransactorSession) SendReward(_reward *big.Int, _dest common.Address, _id *big.Int) (*types.Transaction, error)

SendReward is a paid mutator transaction binding the contract method 0x2673bd74.

Solidity: function sendReward(_reward uint256, _dest address, _id uint256) returns()

func (*RoomTransactorSession) TransferOwnership 

func (_Room *RoomTransactorSession) TransferOwnership(_newOwner common.Address) (*types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(_newOwner address) returns()

func (*RoomTransactorSession) Unpause 

func (_Room *RoomTransactorSession) Unpause() (*types.Transaction, error)

Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a.

Solidity: function unpause() returns()

type RoomUnpause 

type RoomUnpause struct {
	Raw types.Log // Blockchain specific contextual infos
}

RoomUnpause represents a Unpause event raised by the Room contract.

type RoomUnpauseIterator 

type RoomUnpauseIterator struct {
	Event *RoomUnpause // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

RoomUnpauseIterator is returned from FilterUnpause and is used to iterate over the raw logs and unpacked data for Unpause events raised by the Room contract.

func (*RoomUnpauseIterator) Close 

func (it *RoomUnpauseIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*RoomUnpauseIterator) Error 

func (it *RoomUnpauseIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RoomUnpauseIterator) Next 

func (it *RoomUnpauseIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.