balfactory

package
v1.4.1-rc-21 Latest Latest
Warning

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

 Go to latest Published: Mar 2, 2022 License: GPL-2.0 Imports: 8 Imported by: 0

Documentation

Index

Constants

View Source 
const BalfactoryABI = "" /* 1931-byte string literal not displayed */

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

Variables

This section is empty.

Functions

This section is empty.

Types

type Balfactory 

type Balfactory struct {
	BalfactoryCaller     // Read-only binding to the contract
	BalfactoryTransactor // Write-only binding to the contract
	BalfactoryFilterer   // Log filterer for contract events
}

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

func NewBalfactory 

func NewBalfactory(address common.Address, backend bind.ContractBackend) (*Balfactory, error)

NewBalfactory creates a new instance of Balfactory, bound to a specific deployed contract.

type BalfactoryCaller 

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

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

func NewBalfactoryCaller 

func NewBalfactoryCaller(address common.Address, caller bind.ContractCaller) (*BalfactoryCaller, error)

NewBalfactoryCaller creates a new read-only instance of Balfactory, bound to a specific deployed contract.

func (*BalfactoryCaller) GetBLabs 

func (_Balfactory *BalfactoryCaller) GetBLabs(opts *bind.CallOpts) (common.Address, error)

GetBLabs is a free data retrieval call binding the contract method 0x36ffb167.

Solidity: function getBLabs() view returns(address)

func (*BalfactoryCaller) GetColor 

func (_Balfactory *BalfactoryCaller) GetColor(opts *bind.CallOpts) ([32]byte, error)

GetColor is a free data retrieval call binding the contract method 0x9a86139b.

Solidity: function getColor() view returns(bytes32)

func (*BalfactoryCaller) IsBPool 

func (_Balfactory *BalfactoryCaller) IsBPool(opts *bind.CallOpts, b common.Address) (bool, error)

IsBPool is a free data retrieval call binding the contract method 0xc2bb6dc2.

Solidity: function isBPool(address b) view returns(bool)

type BalfactoryCallerRaw 

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

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

func (*BalfactoryCallerRaw) Call 

func (_Balfactory *BalfactoryCallerRaw) 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 BalfactoryCallerSession 

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

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

func (*BalfactoryCallerSession) GetBLabs 

func (_Balfactory *BalfactoryCallerSession) GetBLabs() (common.Address, error)

GetBLabs is a free data retrieval call binding the contract method 0x36ffb167.

Solidity: function getBLabs() view returns(address)

func (*BalfactoryCallerSession) GetColor 

func (_Balfactory *BalfactoryCallerSession) GetColor() ([32]byte, error)

GetColor is a free data retrieval call binding the contract method 0x9a86139b.

Solidity: function getColor() view returns(bytes32)

func (*BalfactoryCallerSession) IsBPool 

func (_Balfactory *BalfactoryCallerSession) IsBPool(b common.Address) (bool, error)

IsBPool is a free data retrieval call binding the contract method 0xc2bb6dc2.

Solidity: function isBPool(address b) view returns(bool)

type BalfactoryFilterer 

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

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

func NewBalfactoryFilterer 

func NewBalfactoryFilterer(address common.Address, filterer bind.ContractFilterer) (*BalfactoryFilterer, error)

NewBalfactoryFilterer creates a new log filterer instance of Balfactory, bound to a specific deployed contract.

func (*BalfactoryFilterer) FilterLOGBLABS 

func (_Balfactory *BalfactoryFilterer) FilterLOGBLABS(opts *bind.FilterOpts, caller []common.Address, blabs []common.Address) (*BalfactoryLOGBLABSIterator, error)

FilterLOGBLABS is a free log retrieval operation binding the contract event 0xf586fa6ee1fc42f5b727f3b214ccbd0b6d7e698c45d49ba32f224fbb8670155d.

Solidity: event LOG_BLABS(address indexed caller, address indexed blabs)

func (*BalfactoryFilterer) FilterLOGNEWPOOL 

func (_Balfactory *BalfactoryFilterer) FilterLOGNEWPOOL(opts *bind.FilterOpts, caller []common.Address, pool []common.Address) (*BalfactoryLOGNEWPOOLIterator, error)

FilterLOGNEWPOOL is a free log retrieval operation binding the contract event 0x8ccec77b0cb63ac2cafd0f5de8cdfadab91ce656d262240ba8a6343bccc5f945.

Solidity: event LOG_NEW_POOL(address indexed caller, address indexed pool)

func (*BalfactoryFilterer) ParseLOGBLABS 

func (_Balfactory *BalfactoryFilterer) ParseLOGBLABS(log types.Log) (*BalfactoryLOGBLABS, error)

ParseLOGBLABS is a log parse operation binding the contract event 0xf586fa6ee1fc42f5b727f3b214ccbd0b6d7e698c45d49ba32f224fbb8670155d.

Solidity: event LOG_BLABS(address indexed caller, address indexed blabs)

func (*BalfactoryFilterer) ParseLOGNEWPOOL 

func (_Balfactory *BalfactoryFilterer) ParseLOGNEWPOOL(log types.Log) (*BalfactoryLOGNEWPOOL, error)

ParseLOGNEWPOOL is a log parse operation binding the contract event 0x8ccec77b0cb63ac2cafd0f5de8cdfadab91ce656d262240ba8a6343bccc5f945.

Solidity: event LOG_NEW_POOL(address indexed caller, address indexed pool)

func (*BalfactoryFilterer) WatchLOGBLABS 

func (_Balfactory *BalfactoryFilterer) WatchLOGBLABS(opts *bind.WatchOpts, sink chan<- *BalfactoryLOGBLABS, caller []common.Address, blabs []common.Address) (event.Subscription, error)

WatchLOGBLABS is a free log subscription operation binding the contract event 0xf586fa6ee1fc42f5b727f3b214ccbd0b6d7e698c45d49ba32f224fbb8670155d.

Solidity: event LOG_BLABS(address indexed caller, address indexed blabs)

func (*BalfactoryFilterer) WatchLOGNEWPOOL 

func (_Balfactory *BalfactoryFilterer) WatchLOGNEWPOOL(opts *bind.WatchOpts, sink chan<- *BalfactoryLOGNEWPOOL, caller []common.Address, pool []common.Address) (event.Subscription, error)

WatchLOGNEWPOOL is a free log subscription operation binding the contract event 0x8ccec77b0cb63ac2cafd0f5de8cdfadab91ce656d262240ba8a6343bccc5f945.

Solidity: event LOG_NEW_POOL(address indexed caller, address indexed pool)

type BalfactoryLOGBLABS 

type BalfactoryLOGBLABS struct {
	Caller common.Address
	Blabs  common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

BalfactoryLOGBLABS represents a LOGBLABS event raised by the Balfactory contract.

type BalfactoryLOGBLABSIterator 

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

BalfactoryLOGBLABSIterator is returned from FilterLOGBLABS and is used to iterate over the raw logs and unpacked data for LOGBLABS events raised by the Balfactory contract.

func (*BalfactoryLOGBLABSIterator) Close 

func (it *BalfactoryLOGBLABSIterator) Close() error

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

func (*BalfactoryLOGBLABSIterator) Error 

func (it *BalfactoryLOGBLABSIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*BalfactoryLOGBLABSIterator) Next 

func (it *BalfactoryLOGBLABSIterator) 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 BalfactoryLOGNEWPOOL 

type BalfactoryLOGNEWPOOL struct {
	Caller common.Address
	Pool   common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

BalfactoryLOGNEWPOOL represents a LOGNEWPOOL event raised by the Balfactory contract.

type BalfactoryLOGNEWPOOLIterator 

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

BalfactoryLOGNEWPOOLIterator is returned from FilterLOGNEWPOOL and is used to iterate over the raw logs and unpacked data for LOGNEWPOOL events raised by the Balfactory contract.

func (*BalfactoryLOGNEWPOOLIterator) Close 

func (it *BalfactoryLOGNEWPOOLIterator) Close() error

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

func (*BalfactoryLOGNEWPOOLIterator) Error 

func (it *BalfactoryLOGNEWPOOLIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*BalfactoryLOGNEWPOOLIterator) Next 

func (it *BalfactoryLOGNEWPOOLIterator) 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 BalfactoryRaw 

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

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

func (*BalfactoryRaw) Call 

func (_Balfactory *BalfactoryRaw) 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 (*BalfactoryRaw) Transact 

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

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

func (*BalfactoryRaw) Transfer 

func (_Balfactory *BalfactoryRaw) 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 BalfactorySession 

type BalfactorySession struct {
	Contract     *Balfactory       // 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
}

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

func (*BalfactorySession) Collect 

func (_Balfactory *BalfactorySession) Collect(pool common.Address) (*types.Transaction, error)

Collect is a paid mutator transaction binding the contract method 0x06ec16f8.

Solidity: function collect(address pool) returns()

func (*BalfactorySession) GetBLabs 

func (_Balfactory *BalfactorySession) GetBLabs() (common.Address, error)

GetBLabs is a free data retrieval call binding the contract method 0x36ffb167.

Solidity: function getBLabs() view returns(address)

func (*BalfactorySession) GetColor 

func (_Balfactory *BalfactorySession) GetColor() ([32]byte, error)

GetColor is a free data retrieval call binding the contract method 0x9a86139b.

Solidity: function getColor() view returns(bytes32)

func (*BalfactorySession) IsBPool 

func (_Balfactory *BalfactorySession) IsBPool(b common.Address) (bool, error)

IsBPool is a free data retrieval call binding the contract method 0xc2bb6dc2.

Solidity: function isBPool(address b) view returns(bool)

func (*BalfactorySession) NewBPool 

func (_Balfactory *BalfactorySession) NewBPool() (*types.Transaction, error)

NewBPool is a paid mutator transaction binding the contract method 0xd556c5dc.

Solidity: function newBPool() returns(address)

func (*BalfactorySession) SetBLabs 

func (_Balfactory *BalfactorySession) SetBLabs(b common.Address) (*types.Transaction, error)

SetBLabs is a paid mutator transaction binding the contract method 0xc6ce34fb.

Solidity: function setBLabs(address b) returns()

type BalfactoryTransactor 

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

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

func NewBalfactoryTransactor 

func NewBalfactoryTransactor(address common.Address, transactor bind.ContractTransactor) (*BalfactoryTransactor, error)

NewBalfactoryTransactor creates a new write-only instance of Balfactory, bound to a specific deployed contract.

func (*BalfactoryTransactor) Collect 

func (_Balfactory *BalfactoryTransactor) Collect(opts *bind.TransactOpts, pool common.Address) (*types.Transaction, error)

Collect is a paid mutator transaction binding the contract method 0x06ec16f8.

Solidity: function collect(address pool) returns()

func (*BalfactoryTransactor) NewBPool 

func (_Balfactory *BalfactoryTransactor) NewBPool(opts *bind.TransactOpts) (*types.Transaction, error)

NewBPool is a paid mutator transaction binding the contract method 0xd556c5dc.

Solidity: function newBPool() returns(address)

func (*BalfactoryTransactor) SetBLabs 

func (_Balfactory *BalfactoryTransactor) SetBLabs(opts *bind.TransactOpts, b common.Address) (*types.Transaction, error)

SetBLabs is a paid mutator transaction binding the contract method 0xc6ce34fb.

Solidity: function setBLabs(address b) returns()

type BalfactoryTransactorRaw 

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

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

func (*BalfactoryTransactorRaw) Transact 

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

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

func (*BalfactoryTransactorRaw) Transfer 

func (_Balfactory *BalfactoryTransactorRaw) 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 BalfactoryTransactorSession 

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

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

func (*BalfactoryTransactorSession) Collect 

func (_Balfactory *BalfactoryTransactorSession) Collect(pool common.Address) (*types.Transaction, error)

Collect is a paid mutator transaction binding the contract method 0x06ec16f8.

Solidity: function collect(address pool) returns()

func (*BalfactoryTransactorSession) NewBPool 

func (_Balfactory *BalfactoryTransactorSession) NewBPool() (*types.Transaction, error)

NewBPool is a paid mutator transaction binding the contract method 0xd556c5dc.

Solidity: function newBPool() returns(address)

func (*BalfactoryTransactorSession) SetBLabs 

func (_Balfactory *BalfactoryTransactorSession) SetBLabs(b common.Address) (*types.Transaction, error)

SetBLabs is a paid mutator transaction binding the contract method 0xc6ce34fb.

Solidity: function setBLabs(address b) returns()

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.