Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

uniswapv3

package

Go to main page

Versions in this module

v0

v0.12.0

Oct 7, 2023

v0.11.4

Sep 22, 2023

v0.11.3

Sep 21, 2023

v0.11.2

Sep 21, 2023

v0.11.1

Sep 2, 2023

v0.11.0

Jul 24, 2023

v0.10.1

Jul 10, 2023

v0.10.0

Jul 9, 2023

v0.9.3

Jun 29, 2023

v0.9.2

Jun 28, 2023

v0.9.1

Jun 26, 2023

v0.9.0

Jun 21, 2023

v0.8.2

Jun 16, 2023

v0.8.1

Jun 16, 2023

v0.8.0

Jun 15, 2023

v0.7.6

Jun 14, 2023

v0.7.5

Jun 13, 2023

v0.7.4

Jun 10, 2023

v0.7.3

Jun 10, 2023

v0.7.2

May 31, 2023

v0.7.1

May 31, 2023

v0.7.0

May 21, 2023

v0.6.3

May 14, 2023

v0.6.2

May 14, 2023

v0.6.1

May 10, 2023

Changes in this version

+ var FactoryABI = FactoryMetaData.ABI

+ var FactoryMetaData = &bind.MetaData

+ var PoolABI = PoolMetaData.ABI

+ var PoolMetaData = &bind.MetaData

+ var QuoterABI = QuoterMetaData.ABI

+ var QuoterMetaData = &bind.MetaData

+ var QuoterV2ABI = QuoterV2MetaData.ABI

+ var QuoterV2MetaData = &bind.MetaData

+ type Factory struct

+ func NewFactory(address common.Address, backend bind.ContractBackend) (*Factory, error)

+ type FactoryCaller struct

+ func NewFactoryCaller(address common.Address, caller bind.ContractCaller) (*FactoryCaller, error)

+ func (_Factory *FactoryCaller) FeeAmountTickSpacing(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error)

+ func (_Factory *FactoryCaller) GetPool(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address, arg2 *big.Int) (common.Address, error)

+ func (_Factory *FactoryCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_Factory *FactoryCaller) Parameters(opts *bind.CallOpts) (struct{ ... }, error)

+ type FactoryCallerRaw struct

+ Contract *FactoryCaller

+ func (_Factory *FactoryCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type FactoryCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *FactoryCaller

+ func (_Factory *FactoryCallerSession) FeeAmountTickSpacing(arg0 *big.Int) (*big.Int, error)

+ func (_Factory *FactoryCallerSession) GetPool(arg0 common.Address, arg1 common.Address, arg2 *big.Int) (common.Address, error)

+ func (_Factory *FactoryCallerSession) Owner() (common.Address, error)

+ func (_Factory *FactoryCallerSession) Parameters() (struct{ ... }, error)

+ type FactoryFeeAmountEnabled struct

+ Fee *big.Int

+ Raw types.Log

+ TickSpacing *big.Int

+ type FactoryFeeAmountEnabledIterator struct

+ Event *FactoryFeeAmountEnabled

+ func (it *FactoryFeeAmountEnabledIterator) Close() error

+ func (it *FactoryFeeAmountEnabledIterator) Error() error

+ func (it *FactoryFeeAmountEnabledIterator) Next() bool

+ type FactoryFilterer struct

+ func NewFactoryFilterer(address common.Address, filterer bind.ContractFilterer) (*FactoryFilterer, error)

+ func (_Factory *FactoryFilterer) FilterFeeAmountEnabled(opts *bind.FilterOpts, fee []*big.Int, tickSpacing []*big.Int) (*FactoryFeeAmountEnabledIterator, error)

+ func (_Factory *FactoryFilterer) FilterOwnerChanged(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*FactoryOwnerChangedIterator, error)

+ func (_Factory *FactoryFilterer) FilterPoolCreated(opts *bind.FilterOpts, token0 []common.Address, token1 []common.Address, ...) (*FactoryPoolCreatedIterator, error)

+ func (_Factory *FactoryFilterer) ParseFeeAmountEnabled(log types.Log) (*FactoryFeeAmountEnabled, error)

+ func (_Factory *FactoryFilterer) ParseOwnerChanged(log types.Log) (*FactoryOwnerChanged, error)

+ func (_Factory *FactoryFilterer) ParsePoolCreated(log types.Log) (*FactoryPoolCreated, error)

+ func (_Factory *FactoryFilterer) WatchFeeAmountEnabled(opts *bind.WatchOpts, sink chan<- *FactoryFeeAmountEnabled, fee []*big.Int, ...) (event.Subscription, error)

+ func (_Factory *FactoryFilterer) WatchOwnerChanged(opts *bind.WatchOpts, sink chan<- *FactoryOwnerChanged, ...) (event.Subscription, error)

+ func (_Factory *FactoryFilterer) WatchPoolCreated(opts *bind.WatchOpts, sink chan<- *FactoryPoolCreated, token0 []common.Address, ...) (event.Subscription, error)

+ type FactoryOwnerChanged struct

+ NewOwner common.Address

+ OldOwner common.Address

+ Raw types.Log

+ type FactoryOwnerChangedIterator struct

+ Event *FactoryOwnerChanged

+ func (it *FactoryOwnerChangedIterator) Close() error

+ func (it *FactoryOwnerChangedIterator) Error() error

+ func (it *FactoryOwnerChangedIterator) Next() bool

+ type FactoryPoolCreated struct

+ Fee *big.Int

+ Pool common.Address

+ Raw types.Log

+ TickSpacing *big.Int

+ Token0 common.Address

+ Token1 common.Address

+ type FactoryPoolCreatedIterator struct

+ Event *FactoryPoolCreated

+ func (it *FactoryPoolCreatedIterator) Close() error

+ func (it *FactoryPoolCreatedIterator) Error() error

+ func (it *FactoryPoolCreatedIterator) Next() bool

+ type FactoryRaw struct

+ Contract *Factory

+ func (_Factory *FactoryRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_Factory *FactoryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type FactorySession struct

+ CallOpts bind.CallOpts

+ Contract *Factory

+ TransactOpts bind.TransactOpts

+ func (_Factory *FactorySession) CreatePool(tokenA common.Address, tokenB common.Address, fee *big.Int) (*types.Transaction, error)

+ func (_Factory *FactorySession) EnableFeeAmount(fee *big.Int, tickSpacing *big.Int) (*types.Transaction, error)

+ func (_Factory *FactorySession) FeeAmountTickSpacing(arg0 *big.Int) (*big.Int, error)

+ func (_Factory *FactorySession) GetPool(arg0 common.Address, arg1 common.Address, arg2 *big.Int) (common.Address, error)

+ func (_Factory *FactorySession) Owner() (common.Address, error)

+ func (_Factory *FactorySession) Parameters() (struct{ ... }, error)

+ func (_Factory *FactorySession) SetOwner(_owner common.Address) (*types.Transaction, error)

+ type FactoryTransactor struct

+ func NewFactoryTransactor(address common.Address, transactor bind.ContractTransactor) (*FactoryTransactor, error)

+ func (_Factory *FactoryTransactor) CreatePool(opts *bind.TransactOpts, tokenA common.Address, tokenB common.Address, ...) (*types.Transaction, error)

+ func (_Factory *FactoryTransactor) EnableFeeAmount(opts *bind.TransactOpts, fee *big.Int, tickSpacing *big.Int) (*types.Transaction, error)

+ func (_Factory *FactoryTransactor) SetOwner(opts *bind.TransactOpts, _owner common.Address) (*types.Transaction, error)

+ type FactoryTransactorRaw struct

+ Contract *FactoryTransactor

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

+ func (_Factory *FactoryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type FactoryTransactorSession struct

+ Contract *FactoryTransactor

+ TransactOpts bind.TransactOpts

+ func (_Factory *FactoryTransactorSession) CreatePool(tokenA common.Address, tokenB common.Address, fee *big.Int) (*types.Transaction, error)

+ func (_Factory *FactoryTransactorSession) EnableFeeAmount(fee *big.Int, tickSpacing *big.Int) (*types.Transaction, error)

+ func (_Factory *FactoryTransactorSession) SetOwner(_owner common.Address) (*types.Transaction, error)

+ type IQuoterV2QuoteExactInputSingleParams struct

+ AmountIn *big.Int

+ Fee *big.Int

+ SqrtPriceLimitX96 *big.Int

+ TokenIn common.Address

+ TokenOut common.Address

+ type IQuoterV2QuoteExactOutputSingleParams struct

+ Amount *big.Int

+ Fee *big.Int

+ SqrtPriceLimitX96 *big.Int

+ TokenIn common.Address

+ TokenOut common.Address

+ type Pool struct

+ func NewPool(address common.Address, backend bind.ContractBackend) (*Pool, error)

+ type PoolBurn struct

+ Amount *big.Int

+ Amount0 *big.Int

+ Amount1 *big.Int

+ Owner common.Address

+ Raw types.Log

+ TickLower *big.Int

+ TickUpper *big.Int

+ type PoolBurnIterator struct

+ Event *PoolBurn

+ func (it *PoolBurnIterator) Close() error

+ func (it *PoolBurnIterator) Error() error

+ func (it *PoolBurnIterator) Next() bool

+ type PoolCaller struct

+ func NewPoolCaller(address common.Address, caller bind.ContractCaller) (*PoolCaller, error)

+ func (_Pool *PoolCaller) Factory(opts *bind.CallOpts) (common.Address, error)

+ func (_Pool *PoolCaller) Fee(opts *bind.CallOpts) (*big.Int, error)

+ func (_Pool *PoolCaller) FeeGrowthGlobal0X128(opts *bind.CallOpts) (*big.Int, error)

+ func (_Pool *PoolCaller) FeeGrowthGlobal1X128(opts *bind.CallOpts) (*big.Int, error)

+ func (_Pool *PoolCaller) Liquidity(opts *bind.CallOpts) (*big.Int, error)

+ func (_Pool *PoolCaller) MaxLiquidityPerTick(opts *bind.CallOpts) (*big.Int, error)

+ func (_Pool *PoolCaller) Observations(opts *bind.CallOpts, arg0 *big.Int) (struct{ ... }, error)

+ func (_Pool *PoolCaller) Observe(opts *bind.CallOpts, secondsAgos []uint32) (struct{ ... }, error)

+ func (_Pool *PoolCaller) Positions(opts *bind.CallOpts, arg0 [32]byte) (struct{ ... }, error)

+ func (_Pool *PoolCaller) ProtocolFees(opts *bind.CallOpts) (struct{ ... }, error)

+ func (_Pool *PoolCaller) Slot0(opts *bind.CallOpts) (struct{ ... }, error)

+ func (_Pool *PoolCaller) SnapshotCumulativesInside(opts *bind.CallOpts, tickLower *big.Int, tickUpper *big.Int) (struct{ ... }, error)

+ func (_Pool *PoolCaller) TickBitmap(opts *bind.CallOpts, arg0 int16) (*big.Int, error)

+ func (_Pool *PoolCaller) TickSpacing(opts *bind.CallOpts) (*big.Int, error)

+ func (_Pool *PoolCaller) Ticks(opts *bind.CallOpts, arg0 *big.Int) (struct{ ... }, error)

+ func (_Pool *PoolCaller) Token0(opts *bind.CallOpts) (common.Address, error)

+ func (_Pool *PoolCaller) Token1(opts *bind.CallOpts) (common.Address, error)

+ type PoolCallerRaw struct

+ Contract *PoolCaller

+ func (_Pool *PoolCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type PoolCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *PoolCaller

+ func (_Pool *PoolCallerSession) Factory() (common.Address, error)

+ func (_Pool *PoolCallerSession) Fee() (*big.Int, error)

+ func (_Pool *PoolCallerSession) FeeGrowthGlobal0X128() (*big.Int, error)

+ func (_Pool *PoolCallerSession) FeeGrowthGlobal1X128() (*big.Int, error)

+ func (_Pool *PoolCallerSession) Liquidity() (*big.Int, error)

+ func (_Pool *PoolCallerSession) MaxLiquidityPerTick() (*big.Int, error)

+ func (_Pool *PoolCallerSession) Observations(arg0 *big.Int) (struct{ ... }, error)

+ func (_Pool *PoolCallerSession) Observe(secondsAgos []uint32) (struct{ ... }, error)

+ func (_Pool *PoolCallerSession) Positions(arg0 [32]byte) (struct{ ... }, error)

+ func (_Pool *PoolCallerSession) ProtocolFees() (struct{ ... }, error)

+ func (_Pool *PoolCallerSession) Slot0() (struct{ ... }, error)

+ func (_Pool *PoolCallerSession) SnapshotCumulativesInside(tickLower *big.Int, tickUpper *big.Int) (struct{ ... }, error)

+ func (_Pool *PoolCallerSession) TickBitmap(arg0 int16) (*big.Int, error)

+ func (_Pool *PoolCallerSession) TickSpacing() (*big.Int, error)

+ func (_Pool *PoolCallerSession) Ticks(arg0 *big.Int) (struct{ ... }, error)

+ func (_Pool *PoolCallerSession) Token0() (common.Address, error)

+ func (_Pool *PoolCallerSession) Token1() (common.Address, error)

+ type PoolCollect struct

+ Amount0 *big.Int

+ Amount1 *big.Int

+ Owner common.Address

+ Raw types.Log

+ Recipient common.Address

+ TickLower *big.Int

+ TickUpper *big.Int

+ type PoolCollectIterator struct

+ Event *PoolCollect

+ func (it *PoolCollectIterator) Close() error

+ func (it *PoolCollectIterator) Error() error

+ func (it *PoolCollectIterator) Next() bool

+ type PoolCollectProtocol struct

+ Amount0 *big.Int

+ Amount1 *big.Int

+ Raw types.Log

+ Recipient common.Address

+ Sender common.Address

+ type PoolCollectProtocolIterator struct

+ Event *PoolCollectProtocol

+ func (it *PoolCollectProtocolIterator) Close() error

+ func (it *PoolCollectProtocolIterator) Error() error

+ func (it *PoolCollectProtocolIterator) Next() bool

+ type PoolFilterer struct

+ func NewPoolFilterer(address common.Address, filterer bind.ContractFilterer) (*PoolFilterer, error)

+ func (_Pool *PoolFilterer) FilterBurn(opts *bind.FilterOpts, owner []common.Address, tickLower []*big.Int, ...) (*PoolBurnIterator, error)

+ func (_Pool *PoolFilterer) FilterCollect(opts *bind.FilterOpts, owner []common.Address, tickLower []*big.Int, ...) (*PoolCollectIterator, error)

+ func (_Pool *PoolFilterer) FilterCollectProtocol(opts *bind.FilterOpts, sender []common.Address, recipient []common.Address) (*PoolCollectProtocolIterator, error)

+ func (_Pool *PoolFilterer) FilterFlash(opts *bind.FilterOpts, sender []common.Address, recipient []common.Address) (*PoolFlashIterator, error)

+ func (_Pool *PoolFilterer) FilterIncreaseObservationCardinalityNext(opts *bind.FilterOpts) (*PoolIncreaseObservationCardinalityNextIterator, error)

+ func (_Pool *PoolFilterer) FilterInitialize(opts *bind.FilterOpts) (*PoolInitializeIterator, error)

+ func (_Pool *PoolFilterer) FilterMint(opts *bind.FilterOpts, owner []common.Address, tickLower []*big.Int, ...) (*PoolMintIterator, error)

+ func (_Pool *PoolFilterer) FilterSetFeeProtocol(opts *bind.FilterOpts) (*PoolSetFeeProtocolIterator, error)

+ func (_Pool *PoolFilterer) FilterSwap(opts *bind.FilterOpts, sender []common.Address, recipient []common.Address) (*PoolSwapIterator, error)

+ func (_Pool *PoolFilterer) ParseBurn(log types.Log) (*PoolBurn, error)

+ func (_Pool *PoolFilterer) ParseCollect(log types.Log) (*PoolCollect, error)

+ func (_Pool *PoolFilterer) ParseCollectProtocol(log types.Log) (*PoolCollectProtocol, error)

+ func (_Pool *PoolFilterer) ParseFlash(log types.Log) (*PoolFlash, error)

+ func (_Pool *PoolFilterer) ParseIncreaseObservationCardinalityNext(log types.Log) (*PoolIncreaseObservationCardinalityNext, error)

+ func (_Pool *PoolFilterer) ParseInitialize(log types.Log) (*PoolInitialize, error)

+ func (_Pool *PoolFilterer) ParseMint(log types.Log) (*PoolMint, error)

+ func (_Pool *PoolFilterer) ParseSetFeeProtocol(log types.Log) (*PoolSetFeeProtocol, error)

+ func (_Pool *PoolFilterer) ParseSwap(log types.Log) (*PoolSwap, error)

+ func (_Pool *PoolFilterer) WatchBurn(opts *bind.WatchOpts, sink chan<- *PoolBurn, owner []common.Address, ...) (event.Subscription, error)

+ func (_Pool *PoolFilterer) WatchCollect(opts *bind.WatchOpts, sink chan<- *PoolCollect, owner []common.Address, ...) (event.Subscription, error)

+ func (_Pool *PoolFilterer) WatchCollectProtocol(opts *bind.WatchOpts, sink chan<- *PoolCollectProtocol, ...) (event.Subscription, error)

+ func (_Pool *PoolFilterer) WatchFlash(opts *bind.WatchOpts, sink chan<- *PoolFlash, sender []common.Address, ...) (event.Subscription, error)

+ func (_Pool *PoolFilterer) WatchIncreaseObservationCardinalityNext(opts *bind.WatchOpts, sink chan<- *PoolIncreaseObservationCardinalityNext) (event.Subscription, error)

+ func (_Pool *PoolFilterer) WatchInitialize(opts *bind.WatchOpts, sink chan<- *PoolInitialize) (event.Subscription, error)

+ func (_Pool *PoolFilterer) WatchMint(opts *bind.WatchOpts, sink chan<- *PoolMint, owner []common.Address, ...) (event.Subscription, error)

+ func (_Pool *PoolFilterer) WatchSetFeeProtocol(opts *bind.WatchOpts, sink chan<- *PoolSetFeeProtocol) (event.Subscription, error)

+ func (_Pool *PoolFilterer) WatchSwap(opts *bind.WatchOpts, sink chan<- *PoolSwap, sender []common.Address, ...) (event.Subscription, error)

+ type PoolFlash struct

+ Amount0 *big.Int

+ Amount1 *big.Int

+ Paid0 *big.Int

+ Paid1 *big.Int

+ Raw types.Log

+ Recipient common.Address

+ Sender common.Address

+ type PoolFlashIterator struct

+ Event *PoolFlash

+ func (it *PoolFlashIterator) Close() error

+ func (it *PoolFlashIterator) Error() error

+ func (it *PoolFlashIterator) Next() bool

+ type PoolIncreaseObservationCardinalityNext struct

+ ObservationCardinalityNextNew uint16

+ ObservationCardinalityNextOld uint16

+ Raw types.Log

+ type PoolIncreaseObservationCardinalityNextIterator struct

+ Event *PoolIncreaseObservationCardinalityNext

+ func (it *PoolIncreaseObservationCardinalityNextIterator) Close() error

+ func (it *PoolIncreaseObservationCardinalityNextIterator) Error() error

+ func (it *PoolIncreaseObservationCardinalityNextIterator) Next() bool

+ type PoolInitialize struct

+ Raw types.Log

+ SqrtPriceX96 *big.Int

+ Tick *big.Int

+ type PoolInitializeIterator struct

+ Event *PoolInitialize

+ func (it *PoolInitializeIterator) Close() error

+ func (it *PoolInitializeIterator) Error() error

+ func (it *PoolInitializeIterator) Next() bool

+ type PoolMint struct

+ Amount *big.Int

+ Amount0 *big.Int

+ Amount1 *big.Int

+ Owner common.Address

+ Raw types.Log

+ Sender common.Address

+ TickLower *big.Int

+ TickUpper *big.Int

+ type PoolMintIterator struct

+ Event *PoolMint

+ func (it *PoolMintIterator) Close() error

+ func (it *PoolMintIterator) Error() error

+ func (it *PoolMintIterator) Next() bool

+ type PoolRaw struct

+ Contract *Pool

+ func (_Pool *PoolRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_Pool *PoolRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type PoolSession struct

+ CallOpts bind.CallOpts

+ Contract *Pool

+ TransactOpts bind.TransactOpts

+ func (_Pool *PoolSession) Burn(tickLower *big.Int, tickUpper *big.Int, amount *big.Int) (*types.Transaction, error)

+ func (_Pool *PoolSession) Collect(recipient common.Address, tickLower *big.Int, tickUpper *big.Int, ...) (*types.Transaction, error)

+ func (_Pool *PoolSession) CollectProtocol(recipient common.Address, amount0Requested *big.Int, amount1Requested *big.Int) (*types.Transaction, error)

+ func (_Pool *PoolSession) Factory() (common.Address, error)

+ func (_Pool *PoolSession) Fee() (*big.Int, error)

+ func (_Pool *PoolSession) FeeGrowthGlobal0X128() (*big.Int, error)

+ func (_Pool *PoolSession) FeeGrowthGlobal1X128() (*big.Int, error)

+ func (_Pool *PoolSession) Flash(recipient common.Address, amount0 *big.Int, amount1 *big.Int, data []byte) (*types.Transaction, error)

+ func (_Pool *PoolSession) IncreaseObservationCardinalityNext(observationCardinalityNext uint16) (*types.Transaction, error)

+ func (_Pool *PoolSession) Initialize(sqrtPriceX96 *big.Int) (*types.Transaction, error)

+ func (_Pool *PoolSession) Liquidity() (*big.Int, error)

+ func (_Pool *PoolSession) MaxLiquidityPerTick() (*big.Int, error)

+ func (_Pool *PoolSession) Mint(recipient common.Address, tickLower *big.Int, tickUpper *big.Int, ...) (*types.Transaction, error)

+ func (_Pool *PoolSession) Observations(arg0 *big.Int) (struct{ ... }, error)

+ func (_Pool *PoolSession) Observe(secondsAgos []uint32) (struct{ ... }, error)

+ func (_Pool *PoolSession) Positions(arg0 [32]byte) (struct{ ... }, error)

+ func (_Pool *PoolSession) ProtocolFees() (struct{ ... }, error)

+ func (_Pool *PoolSession) SetFeeProtocol(feeProtocol0 uint8, feeProtocol1 uint8) (*types.Transaction, error)

+ func (_Pool *PoolSession) Slot0() (struct{ ... }, error)

+ func (_Pool *PoolSession) SnapshotCumulativesInside(tickLower *big.Int, tickUpper *big.Int) (struct{ ... }, error)

+ func (_Pool *PoolSession) Swap(recipient common.Address, zeroForOne bool, amountSpecified *big.Int, ...) (*types.Transaction, error)

+ func (_Pool *PoolSession) TickBitmap(arg0 int16) (*big.Int, error)

+ func (_Pool *PoolSession) TickSpacing() (*big.Int, error)

+ func (_Pool *PoolSession) Ticks(arg0 *big.Int) (struct{ ... }, error)

+ func (_Pool *PoolSession) Token0() (common.Address, error)

+ func (_Pool *PoolSession) Token1() (common.Address, error)

+ type PoolSetFeeProtocol struct

+ FeeProtocol0New uint8

+ FeeProtocol0Old uint8

+ FeeProtocol1New uint8

+ FeeProtocol1Old uint8

+ Raw types.Log

+ type PoolSetFeeProtocolIterator struct

+ Event *PoolSetFeeProtocol

+ func (it *PoolSetFeeProtocolIterator) Close() error

+ func (it *PoolSetFeeProtocolIterator) Error() error

+ func (it *PoolSetFeeProtocolIterator) Next() bool

+ type PoolSwap struct

+ Amount0 *big.Int

+ Amount1 *big.Int

+ Liquidity *big.Int

+ Raw types.Log

+ Recipient common.Address

+ Sender common.Address

+ SqrtPriceX96 *big.Int

+ Tick *big.Int

+ type PoolSwapIterator struct

+ Event *PoolSwap

+ func (it *PoolSwapIterator) Close() error

+ func (it *PoolSwapIterator) Error() error

+ func (it *PoolSwapIterator) Next() bool

+ type PoolTransactor struct

+ func NewPoolTransactor(address common.Address, transactor bind.ContractTransactor) (*PoolTransactor, error)

+ func (_Pool *PoolTransactor) Burn(opts *bind.TransactOpts, tickLower *big.Int, tickUpper *big.Int, ...) (*types.Transaction, error)

+ func (_Pool *PoolTransactor) Collect(opts *bind.TransactOpts, recipient common.Address, tickLower *big.Int, ...) (*types.Transaction, error)

+ func (_Pool *PoolTransactor) CollectProtocol(opts *bind.TransactOpts, recipient common.Address, amount0Requested *big.Int, ...) (*types.Transaction, error)

+ func (_Pool *PoolTransactor) Flash(opts *bind.TransactOpts, recipient common.Address, amount0 *big.Int, ...) (*types.Transaction, error)

+ func (_Pool *PoolTransactor) IncreaseObservationCardinalityNext(opts *bind.TransactOpts, observationCardinalityNext uint16) (*types.Transaction, error)

+ func (_Pool *PoolTransactor) Initialize(opts *bind.TransactOpts, sqrtPriceX96 *big.Int) (*types.Transaction, error)

+ func (_Pool *PoolTransactor) Mint(opts *bind.TransactOpts, recipient common.Address, tickLower *big.Int, ...) (*types.Transaction, error)

+ func (_Pool *PoolTransactor) SetFeeProtocol(opts *bind.TransactOpts, feeProtocol0 uint8, feeProtocol1 uint8) (*types.Transaction, error)

+ func (_Pool *PoolTransactor) Swap(opts *bind.TransactOpts, recipient common.Address, zeroForOne bool, ...) (*types.Transaction, error)

+ type PoolTransactorRaw struct

+ Contract *PoolTransactor

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

+ func (_Pool *PoolTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type PoolTransactorSession struct

+ Contract *PoolTransactor

+ TransactOpts bind.TransactOpts

+ func (_Pool *PoolTransactorSession) Burn(tickLower *big.Int, tickUpper *big.Int, amount *big.Int) (*types.Transaction, error)

+ func (_Pool *PoolTransactorSession) Collect(recipient common.Address, tickLower *big.Int, tickUpper *big.Int, ...) (*types.Transaction, error)

+ func (_Pool *PoolTransactorSession) CollectProtocol(recipient common.Address, amount0Requested *big.Int, amount1Requested *big.Int) (*types.Transaction, error)

+ func (_Pool *PoolTransactorSession) Flash(recipient common.Address, amount0 *big.Int, amount1 *big.Int, data []byte) (*types.Transaction, error)

+ func (_Pool *PoolTransactorSession) IncreaseObservationCardinalityNext(observationCardinalityNext uint16) (*types.Transaction, error)

+ func (_Pool *PoolTransactorSession) Initialize(sqrtPriceX96 *big.Int) (*types.Transaction, error)

+ func (_Pool *PoolTransactorSession) Mint(recipient common.Address, tickLower *big.Int, tickUpper *big.Int, ...) (*types.Transaction, error)

+ func (_Pool *PoolTransactorSession) SetFeeProtocol(feeProtocol0 uint8, feeProtocol1 uint8) (*types.Transaction, error)

+ func (_Pool *PoolTransactorSession) Swap(recipient common.Address, zeroForOne bool, amountSpecified *big.Int, ...) (*types.Transaction, error)

+ type Quoter struct

+ func NewQuoter(address common.Address, backend bind.ContractBackend) (*Quoter, error)

+ type QuoterCaller struct

+ func NewQuoterCaller(address common.Address, caller bind.ContractCaller) (*QuoterCaller, error)

+ func (_Quoter *QuoterCaller) Factory(opts *bind.CallOpts) (common.Address, error)

+ func (_Quoter *QuoterCaller) UniswapV3SwapCallback(opts *bind.CallOpts, amount0Delta *big.Int, amount1Delta *big.Int, path []byte) error

+ func (_Quoter *QuoterCaller) WETH9(opts *bind.CallOpts) (common.Address, error)

+ type QuoterCallerRaw struct

+ Contract *QuoterCaller

+ func (_Quoter *QuoterCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type QuoterCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *QuoterCaller

+ func (_Quoter *QuoterCallerSession) Factory() (common.Address, error)

+ func (_Quoter *QuoterCallerSession) UniswapV3SwapCallback(amount0Delta *big.Int, amount1Delta *big.Int, path []byte) error

+ func (_Quoter *QuoterCallerSession) WETH9() (common.Address, error)

+ type QuoterFilterer struct

+ func NewQuoterFilterer(address common.Address, filterer bind.ContractFilterer) (*QuoterFilterer, error)

+ type QuoterRaw struct

+ Contract *Quoter

+ func (_Quoter *QuoterRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_Quoter *QuoterRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type QuoterSession struct

+ CallOpts bind.CallOpts

+ Contract *Quoter

+ TransactOpts bind.TransactOpts

+ func (_Quoter *QuoterSession) Factory() (common.Address, error)

+ func (_Quoter *QuoterSession) QuoteExactInput(path []byte, amountIn *big.Int) (*types.Transaction, error)

+ func (_Quoter *QuoterSession) QuoteExactInputSingle(tokenIn common.Address, tokenOut common.Address, fee *big.Int, ...) (*types.Transaction, error)

+ func (_Quoter *QuoterSession) QuoteExactOutput(path []byte, amountOut *big.Int) (*types.Transaction, error)

+ func (_Quoter *QuoterSession) QuoteExactOutputSingle(tokenIn common.Address, tokenOut common.Address, fee *big.Int, ...) (*types.Transaction, error)

+ func (_Quoter *QuoterSession) UniswapV3SwapCallback(amount0Delta *big.Int, amount1Delta *big.Int, path []byte) error

+ func (_Quoter *QuoterSession) WETH9() (common.Address, error)

+ type QuoterTransactor struct

+ func NewQuoterTransactor(address common.Address, transactor bind.ContractTransactor) (*QuoterTransactor, error)

+ func (_Quoter *QuoterTransactor) QuoteExactInput(opts *bind.TransactOpts, path []byte, amountIn *big.Int) (*types.Transaction, error)

+ func (_Quoter *QuoterTransactor) QuoteExactInputSingle(opts *bind.TransactOpts, tokenIn common.Address, tokenOut common.Address, ...) (*types.Transaction, error)

+ func (_Quoter *QuoterTransactor) QuoteExactOutput(opts *bind.TransactOpts, path []byte, amountOut *big.Int) (*types.Transaction, error)

+ func (_Quoter *QuoterTransactor) QuoteExactOutputSingle(opts *bind.TransactOpts, tokenIn common.Address, tokenOut common.Address, ...) (*types.Transaction, error)

+ type QuoterTransactorRaw struct

+ Contract *QuoterTransactor

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

+ func (_Quoter *QuoterTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type QuoterTransactorSession struct

+ Contract *QuoterTransactor

+ TransactOpts bind.TransactOpts

+ func (_Quoter *QuoterTransactorSession) QuoteExactInput(path []byte, amountIn *big.Int) (*types.Transaction, error)

+ func (_Quoter *QuoterTransactorSession) QuoteExactInputSingle(tokenIn common.Address, tokenOut common.Address, fee *big.Int, ...) (*types.Transaction, error)

+ func (_Quoter *QuoterTransactorSession) QuoteExactOutput(path []byte, amountOut *big.Int) (*types.Transaction, error)

+ func (_Quoter *QuoterTransactorSession) QuoteExactOutputSingle(tokenIn common.Address, tokenOut common.Address, fee *big.Int, ...) (*types.Transaction, error)

+ type QuoterV2 struct

+ func NewQuoterV2(address common.Address, backend bind.ContractBackend) (*QuoterV2, error)

+ type QuoterV2Caller struct

+ func NewQuoterV2Caller(address common.Address, caller bind.ContractCaller) (*QuoterV2Caller, error)

+ func (_QuoterV2 *QuoterV2Caller) Factory(opts *bind.CallOpts) (common.Address, error)

+ func (_QuoterV2 *QuoterV2Caller) UniswapV3SwapCallback(opts *bind.CallOpts, amount0Delta *big.Int, amount1Delta *big.Int, path []byte) error

+ func (_QuoterV2 *QuoterV2Caller) WETH9(opts *bind.CallOpts) (common.Address, error)

+ type QuoterV2CallerRaw struct

+ Contract *QuoterV2Caller

+ func (_QuoterV2 *QuoterV2CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type QuoterV2CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *QuoterV2Caller

+ func (_QuoterV2 *QuoterV2CallerSession) Factory() (common.Address, error)

+ func (_QuoterV2 *QuoterV2CallerSession) UniswapV3SwapCallback(amount0Delta *big.Int, amount1Delta *big.Int, path []byte) error

+ func (_QuoterV2 *QuoterV2CallerSession) WETH9() (common.Address, error)

+ type QuoterV2Filterer struct

+ func NewQuoterV2Filterer(address common.Address, filterer bind.ContractFilterer) (*QuoterV2Filterer, error)

+ type QuoterV2Raw struct

+ Contract *QuoterV2

+ func (_QuoterV2 *QuoterV2Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

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

+ func (_QuoterV2 *QuoterV2Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type QuoterV2Session struct

+ CallOpts bind.CallOpts

+ Contract *QuoterV2

+ TransactOpts bind.TransactOpts

+ func (_QuoterV2 *QuoterV2Session) Factory() (common.Address, error)

+ func (_QuoterV2 *QuoterV2Session) QuoteExactInput(path []byte, amountIn *big.Int) (*types.Transaction, error)

+ func (_QuoterV2 *QuoterV2Session) QuoteExactInputSingle(params IQuoterV2QuoteExactInputSingleParams) (*types.Transaction, error)

+ func (_QuoterV2 *QuoterV2Session) QuoteExactOutput(path []byte, amountOut *big.Int) (*types.Transaction, error)

+ func (_QuoterV2 *QuoterV2Session) QuoteExactOutputSingle(params IQuoterV2QuoteExactOutputSingleParams) (*types.Transaction, error)

+ func (_QuoterV2 *QuoterV2Session) UniswapV3SwapCallback(amount0Delta *big.Int, amount1Delta *big.Int, path []byte) error

+ func (_QuoterV2 *QuoterV2Session) WETH9() (common.Address, error)

+ type QuoterV2Transactor struct

+ func NewQuoterV2Transactor(address common.Address, transactor bind.ContractTransactor) (*QuoterV2Transactor, error)

+ func (_QuoterV2 *QuoterV2Transactor) QuoteExactInput(opts *bind.TransactOpts, path []byte, amountIn *big.Int) (*types.Transaction, error)

+ func (_QuoterV2 *QuoterV2Transactor) QuoteExactInputSingle(opts *bind.TransactOpts, params IQuoterV2QuoteExactInputSingleParams) (*types.Transaction, error)

+ func (_QuoterV2 *QuoterV2Transactor) QuoteExactOutput(opts *bind.TransactOpts, path []byte, amountOut *big.Int) (*types.Transaction, error)

+ func (_QuoterV2 *QuoterV2Transactor) QuoteExactOutputSingle(opts *bind.TransactOpts, params IQuoterV2QuoteExactOutputSingleParams) (*types.Transaction, error)

+ type QuoterV2TransactorRaw struct

+ Contract *QuoterV2Transactor

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

+ func (_QuoterV2 *QuoterV2TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type QuoterV2TransactorSession struct

+ Contract *QuoterV2Transactor

+ TransactOpts bind.TransactOpts

+ func (_QuoterV2 *QuoterV2TransactorSession) QuoteExactInput(path []byte, amountIn *big.Int) (*types.Transaction, error)

+ func (_QuoterV2 *QuoterV2TransactorSession) QuoteExactInputSingle(params IQuoterV2QuoteExactInputSingleParams) (*types.Transaction, error)

+ func (_QuoterV2 *QuoterV2TransactorSession) QuoteExactOutput(path []byte, amountOut *big.Int) (*types.Transaction, error)

+ func (_QuoterV2 *QuoterV2TransactorSession) QuoteExactOutputSingle(params IQuoterV2QuoteExactOutputSingleParams) (*types.Transaction, error)