Logger

Documentation

Index

• Variables
• type Logger
  • func DeployLogger(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Logger, error)
  • func NewLogger(address common.Address, backend bind.ContractBackend) (*Logger, error)
• type LoggerCaller
  • func NewLoggerCaller(address common.Address, caller bind.ContractCaller) (*LoggerCaller, error)
• type LoggerCallerRaw
  • func (_Logger *LoggerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error
• type LoggerCallerSession
• type LoggerFilterer
  • func NewLoggerFilterer(address common.Address, filterer bind.ContractFilterer) (*LoggerFilterer, error)
  • func (_Logger *LoggerFilterer) FilterLogMessage(opts *bind.FilterOpts) (*LoggerLogMessageIterator, error)
  • func (_Logger *LoggerFilterer) ParseLogMessage(log types.Log) (*LoggerLogMessage, error)
  • func (_Logger *LoggerFilterer) WatchLogMessage(opts *bind.WatchOpts, sink chan<- *LoggerLogMessage) (event.Subscription, error)
• type LoggerLogMessage
• type LoggerLogMessageIterator
  • func (it *LoggerLogMessageIterator) Close() error
  • func (it *LoggerLogMessageIterator) Error() error
  • func (it *LoggerLogMessageIterator) Next() bool
• type LoggerRaw
  • func (_Logger *LoggerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error
  • func (_Logger *LoggerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)
  • func (_Logger *LoggerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)
• type LoggerSession
• type LoggerTransactor
  • func NewLoggerTransactor(address common.Address, transactor bind.ContractTransactor) (*LoggerTransactor, error)
• type LoggerTransactorRaw
  • func (_Logger *LoggerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)
  • func (_Logger *LoggerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)
• type LoggerTransactorSession

Variables

var LoggerABI = LoggerMetaData.ABI

LoggerABI is the input ABI used to generate the binding from. Deprecated: Use LoggerMetaData.ABI instead.

var LoggerBin = LoggerMetaData.Bin

LoggerBin is the compiled bytecode used for deploying new contracts. Deprecated: Use LoggerMetaData.Bin instead.

var LoggerMetaData = &bind.MetaData{
	ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"message\",\"type\":\"string\"}],\"name\":\"LogMessage\",\"type\":\"event\"}]",
	Bin: "0x6101a4610034600b8282823980515f1a607314602857634e487b7160e01b5f525f60045260245ffd5b305f52607381538281f3fe7300000000000000000000000000000000000000003014608060405260043610610034575f3560e01c80632e3c2a4d14610038575b5f5ffd5b818015610043575f5ffd5b506100576100523660046100e4565b610059565b005b7f96561394bac381230de4649200e8831afcab1f451881bbade9ef209f6dd30480828260405161008a929190610154565b60405180910390a15050565b5f5f83601f8401126100a9576100a95f5ffd5b50813567ffffffffffffffff8111156100c3576100c35f5ffd5b6020830191508360018202830111156100dd576100dd5f5ffd5b9250929050565b5f5f602083850312156100f8576100f85f5ffd5b823567ffffffffffffffff811115610111576101115f5ffd5b61011d85828601610096565b92509250509250929050565b82818337505f910152565b818352602083019250610148828483610129565b50601f01601f19160190565b60208082528101610166818486610134565b94935050505056fea2646970667358221220c17e115f9813592e239b1a7d8a226e1dda8120f1b090f4dc3727a71ecbd76bb664736f6c634300081c0033",
}

LoggerMetaData contains all meta data concerning the Logger contract.

Types

type Logger

type Logger struct {
	LoggerCaller     // Read-only binding to the contract
	LoggerTransactor // Write-only binding to the contract
	LoggerFilterer   // Log filterer for contract events
}

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

func DeployLogger

func DeployLogger(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Logger, error)

DeployLogger deploys a new Ethereum contract, binding an instance of Logger to it.

func NewLogger

func NewLogger(address common.Address, backend bind.ContractBackend) (*Logger, error)

NewLogger creates a new instance of Logger, bound to a specific deployed contract.

type LoggerCaller

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

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

func NewLoggerCaller

func NewLoggerCaller(address common.Address, caller bind.ContractCaller) (*LoggerCaller, error)

NewLoggerCaller creates a new read-only instance of Logger, bound to a specific deployed contract.

type LoggerCallerRaw

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

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

func (*LoggerCallerRaw) Call

func (_Logger *LoggerCallerRaw) 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 LoggerCallerSession

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

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

type LoggerFilterer

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

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

func NewLoggerFilterer

func NewLoggerFilterer(address common.Address, filterer bind.ContractFilterer) (*LoggerFilterer, error)

NewLoggerFilterer creates a new log filterer instance of Logger, bound to a specific deployed contract.

func (*LoggerFilterer) FilterLogMessage

func (_Logger *LoggerFilterer) FilterLogMessage(opts *bind.FilterOpts) (*LoggerLogMessageIterator, error)

FilterLogMessage is a free log retrieval operation binding the contract event 0x96561394bac381230de4649200e8831afcab1f451881bbade9ef209f6dd30480.

Solidity: event LogMessage(string message)

func (*LoggerFilterer) ParseLogMessage

func (_Logger *LoggerFilterer) ParseLogMessage(log types.Log) (*LoggerLogMessage, error)

ParseLogMessage is a log parse operation binding the contract event 0x96561394bac381230de4649200e8831afcab1f451881bbade9ef209f6dd30480.

Solidity: event LogMessage(string message)

func (*LoggerFilterer) WatchLogMessage

func (_Logger *LoggerFilterer) WatchLogMessage(opts *bind.WatchOpts, sink chan<- *LoggerLogMessage) (event.Subscription, error)

WatchLogMessage is a free log subscription operation binding the contract event 0x96561394bac381230de4649200e8831afcab1f451881bbade9ef209f6dd30480.

Solidity: event LogMessage(string message)

type LoggerLogMessage

type LoggerLogMessage struct {
	Message string
	Raw     types.Log // Blockchain specific contextual infos
}

LoggerLogMessage represents a LogMessage event raised by the Logger contract.

type LoggerLogMessageIterator

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

LoggerLogMessageIterator is returned from FilterLogMessage and is used to iterate over the raw logs and unpacked data for LogMessage events raised by the Logger contract.

func (*LoggerLogMessageIterator) Close

func (it *LoggerLogMessageIterator) Close() error

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

func (*LoggerLogMessageIterator) Error

func (it *LoggerLogMessageIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*LoggerLogMessageIterator) Next

func (it *LoggerLogMessageIterator) 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 LoggerRaw

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

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

func (*LoggerRaw) Call

func (_Logger *LoggerRaw) 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 (*LoggerRaw) Transact

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

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

func (*LoggerRaw) Transfer

func (_Logger *LoggerRaw) 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 LoggerSession

type LoggerSession struct {
	Contract     *Logger           // 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
}

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

type LoggerTransactor

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

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

func NewLoggerTransactor

func NewLoggerTransactor(address common.Address, transactor bind.ContractTransactor) (*LoggerTransactor, error)

NewLoggerTransactor creates a new write-only instance of Logger, bound to a specific deployed contract.

type LoggerTransactorRaw

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

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

func (*LoggerTransactorRaw) Transact

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

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

func (*LoggerTransactorRaw) Transfer

func (_Logger *LoggerTransactorRaw) 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 LoggerTransactorSession

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

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