tridentconcentratedliquiditypoolfactory

Documentation

Index

• Variables
• type ConcentratedLiquidityPoolFactory
  • func NewConcentratedLiquidityPoolFactory(address common.Address, backend bind.ContractBackend) (*ConcentratedLiquidityPoolFactory, error)
• type ConcentratedLiquidityPoolFactoryCaller
  • func NewConcentratedLiquidityPoolFactoryCaller(address common.Address, caller bind.ContractCaller) (*ConcentratedLiquidityPoolFactoryCaller, error)
  • func (_ConcentratedLiquidityPoolFactory *ConcentratedLiquidityPoolFactoryCaller) GetPools(opts *bind.CallOpts, token0 common.Address, token1 common.Address, ...) ([]common.Address, error)
• type ConcentratedLiquidityPoolFactoryCallerRaw
  • func (_ConcentratedLiquidityPoolFactory *ConcentratedLiquidityPoolFactoryCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error
• type ConcentratedLiquidityPoolFactoryCallerSession
  • func (_ConcentratedLiquidityPoolFactory *ConcentratedLiquidityPoolFactoryCallerSession) GetPools(token0 common.Address, token1 common.Address, startIndex *big.Int, ...) ([]common.Address, error)
• type ConcentratedLiquidityPoolFactoryFilterer
  • func NewConcentratedLiquidityPoolFactoryFilterer(address common.Address, filterer bind.ContractFilterer) (*ConcentratedLiquidityPoolFactoryFilterer, error)
• type ConcentratedLiquidityPoolFactoryRaw
  • func (_ConcentratedLiquidityPoolFactory *ConcentratedLiquidityPoolFactoryRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error
  • func (_ConcentratedLiquidityPoolFactory *ConcentratedLiquidityPoolFactoryRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)
  • func (_ConcentratedLiquidityPoolFactory *ConcentratedLiquidityPoolFactoryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)
• type ConcentratedLiquidityPoolFactorySession
  • func (_ConcentratedLiquidityPoolFactory *ConcentratedLiquidityPoolFactorySession) GetPools(token0 common.Address, token1 common.Address, startIndex *big.Int, ...) ([]common.Address, error)
• type ConcentratedLiquidityPoolFactoryTransactor
  • func NewConcentratedLiquidityPoolFactoryTransactor(address common.Address, transactor bind.ContractTransactor) (*ConcentratedLiquidityPoolFactoryTransactor, error)
• type ConcentratedLiquidityPoolFactoryTransactorRaw
  • func (_ConcentratedLiquidityPoolFactory *ConcentratedLiquidityPoolFactoryTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)
  • func (_ConcentratedLiquidityPoolFactory *ConcentratedLiquidityPoolFactoryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)
• type ConcentratedLiquidityPoolFactoryTransactorSession

Variables

var ConcentratedLiquidityPoolFactoryABI = ConcentratedLiquidityPoolFactoryMetaData.ABI

ConcentratedLiquidityPoolFactoryABI is the input ABI used to generate the binding from. Deprecated: Use ConcentratedLiquidityPoolFactoryMetaData.ABI instead.

var ConcentratedLiquidityPoolFactoryMetaData = &bind.MetaData{
	ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token0\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token1\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"startIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"count\",\"type\":\"uint256\"}],\"name\":\"getPools\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"pairPools\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
}

ConcentratedLiquidityPoolFactoryMetaData contains all meta data concerning the ConcentratedLiquidityPoolFactory contract.

Types

type ConcentratedLiquidityPoolFactory

type ConcentratedLiquidityPoolFactory struct {
	ConcentratedLiquidityPoolFactoryCaller     // Read-only binding to the contract
	ConcentratedLiquidityPoolFactoryTransactor // Write-only binding to the contract
	ConcentratedLiquidityPoolFactoryFilterer   // Log filterer for contract events
}

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

func NewConcentratedLiquidityPoolFactory

func NewConcentratedLiquidityPoolFactory(address common.Address, backend bind.ContractBackend) (*ConcentratedLiquidityPoolFactory, error)

NewConcentratedLiquidityPoolFactory creates a new instance of ConcentratedLiquidityPoolFactory, bound to a specific deployed contract.

type ConcentratedLiquidityPoolFactoryCaller

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

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

func NewConcentratedLiquidityPoolFactoryCaller

func NewConcentratedLiquidityPoolFactoryCaller(address common.Address, caller bind.ContractCaller) (*ConcentratedLiquidityPoolFactoryCaller, error)

NewConcentratedLiquidityPoolFactoryCaller creates a new read-only instance of ConcentratedLiquidityPoolFactory, bound to a specific deployed contract.

func (*ConcentratedLiquidityPoolFactoryCaller) GetPools

func (_ConcentratedLiquidityPoolFactory *ConcentratedLiquidityPoolFactoryCaller) GetPools(opts *bind.CallOpts, token0 common.Address, token1 common.Address, startIndex *big.Int, count *big.Int) ([]common.Address, error)

GetPools is a free data retrieval call binding the contract method 0x71a25812.

Solidity: function getPools(address token0, address token1, uint256 startIndex, uint256 count) view returns(address[] pairPools)

type ConcentratedLiquidityPoolFactoryCallerRaw

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

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

func (*ConcentratedLiquidityPoolFactoryCallerRaw) Call

func (_ConcentratedLiquidityPoolFactory *ConcentratedLiquidityPoolFactoryCallerRaw) 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 ConcentratedLiquidityPoolFactoryCallerSession

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

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

func (*ConcentratedLiquidityPoolFactoryCallerSession) GetPools

func (_ConcentratedLiquidityPoolFactory *ConcentratedLiquidityPoolFactoryCallerSession) GetPools(token0 common.Address, token1 common.Address, startIndex *big.Int, count *big.Int) ([]common.Address, error)

GetPools is a free data retrieval call binding the contract method 0x71a25812.

Solidity: function getPools(address token0, address token1, uint256 startIndex, uint256 count) view returns(address[] pairPools)

type ConcentratedLiquidityPoolFactoryFilterer

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

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

func NewConcentratedLiquidityPoolFactoryFilterer

func NewConcentratedLiquidityPoolFactoryFilterer(address common.Address, filterer bind.ContractFilterer) (*ConcentratedLiquidityPoolFactoryFilterer, error)

NewConcentratedLiquidityPoolFactoryFilterer creates a new log filterer instance of ConcentratedLiquidityPoolFactory, bound to a specific deployed contract.

type ConcentratedLiquidityPoolFactoryRaw

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

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

func (*ConcentratedLiquidityPoolFactoryRaw) Call

func (_ConcentratedLiquidityPoolFactory *ConcentratedLiquidityPoolFactoryRaw) 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 (*ConcentratedLiquidityPoolFactoryRaw) Transact

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

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

func (*ConcentratedLiquidityPoolFactoryRaw) Transfer

func (_ConcentratedLiquidityPoolFactory *ConcentratedLiquidityPoolFactoryRaw) 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 ConcentratedLiquidityPoolFactorySession

type ConcentratedLiquidityPoolFactorySession struct {
	Contract     *ConcentratedLiquidityPoolFactory // 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
}

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

func (*ConcentratedLiquidityPoolFactorySession) GetPools

func (_ConcentratedLiquidityPoolFactory *ConcentratedLiquidityPoolFactorySession) GetPools(token0 common.Address, token1 common.Address, startIndex *big.Int, count *big.Int) ([]common.Address, error)

GetPools is a free data retrieval call binding the contract method 0x71a25812.

Solidity: function getPools(address token0, address token1, uint256 startIndex, uint256 count) view returns(address[] pairPools)

type ConcentratedLiquidityPoolFactoryTransactor

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

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

func NewConcentratedLiquidityPoolFactoryTransactor

func NewConcentratedLiquidityPoolFactoryTransactor(address common.Address, transactor bind.ContractTransactor) (*ConcentratedLiquidityPoolFactoryTransactor, error)

NewConcentratedLiquidityPoolFactoryTransactor creates a new write-only instance of ConcentratedLiquidityPoolFactory, bound to a specific deployed contract.

type ConcentratedLiquidityPoolFactoryTransactorRaw

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

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

func (*ConcentratedLiquidityPoolFactoryTransactorRaw) Transact

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

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

func (*ConcentratedLiquidityPoolFactoryTransactorRaw) Transfer

func (_ConcentratedLiquidityPoolFactory *ConcentratedLiquidityPoolFactoryTransactorRaw) 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 ConcentratedLiquidityPoolFactoryTransactorSession

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

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