github.com/diadata-org/diadata@v1.4.593/pkg/dia/scraper/exchange-scrapers/pancakeswapv3/Pancakev3pair.go (about) 1 // Code generated - DO NOT EDIT. 2 // This file is a generated binding and any manual changes will be lost. 3 4 package Pancakev3pair 5 6 import ( 7 "errors" 8 "math/big" 9 "strings" 10 11 ethereum "github.com/ethereum/go-ethereum" 12 "github.com/ethereum/go-ethereum/accounts/abi" 13 "github.com/ethereum/go-ethereum/accounts/abi/bind" 14 "github.com/ethereum/go-ethereum/common" 15 "github.com/ethereum/go-ethereum/core/types" 16 "github.com/ethereum/go-ethereum/event" 17 ) 18 19 // Reference imports to suppress errors if they are not otherwise used. 20 var ( 21 _ = errors.New 22 _ = big.NewInt 23 _ = strings.NewReader 24 _ = ethereum.NotFound 25 _ = bind.Bind 26 _ = common.Big1 27 _ = types.BloomLookup 28 _ = event.NewSubscription 29 _ = abi.ConvertType 30 ) 31 32 // Pancakev3pairMetaData contains all meta data concerning the Pancakev3pair contract. 33 var Pancakev3pairMetaData = &bind.MetaData{ 34 ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"int24\",\"name\":\"tickLower\",\"type\":\"int24\"},{\"indexed\":true,\"internalType\":\"int24\",\"name\":\"tickUpper\",\"type\":\"int24\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"}],\"name\":\"Burn\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"int24\",\"name\":\"tickLower\",\"type\":\"int24\"},{\"indexed\":true,\"internalType\":\"int24\",\"name\":\"tickUpper\",\"type\":\"int24\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount0\",\"type\":\"uint128\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount1\",\"type\":\"uint128\"}],\"name\":\"Collect\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount0\",\"type\":\"uint128\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount1\",\"type\":\"uint128\"}],\"name\":\"CollectProtocol\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"paid0\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"paid1\",\"type\":\"uint256\"}],\"name\":\"Flash\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint16\",\"name\":\"observationCardinalityNextOld\",\"type\":\"uint16\"},{\"indexed\":false,\"internalType\":\"uint16\",\"name\":\"observationCardinalityNextNew\",\"type\":\"uint16\"}],\"name\":\"IncreaseObservationCardinalityNext\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint160\",\"name\":\"sqrtPriceX96\",\"type\":\"uint160\"},{\"indexed\":false,\"internalType\":\"int24\",\"name\":\"tick\",\"type\":\"int24\"}],\"name\":\"Initialize\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"int24\",\"name\":\"tickLower\",\"type\":\"int24\"},{\"indexed\":true,\"internalType\":\"int24\",\"name\":\"tickUpper\",\"type\":\"int24\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"}],\"name\":\"Mint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"feeProtocol0Old\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"feeProtocol1Old\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"feeProtocol0New\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"feeProtocol1New\",\"type\":\"uint32\"}],\"name\":\"SetFeeProtocol\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"SetLmPoolEvent\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"amount0\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"amount1\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint160\",\"name\":\"sqrtPriceX96\",\"type\":\"uint160\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"liquidity\",\"type\":\"uint128\"},{\"indexed\":false,\"internalType\":\"int24\",\"name\":\"tick\",\"type\":\"int24\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"protocolFeesToken0\",\"type\":\"uint128\"},{\"indexed\":false,\"internalType\":\"uint128\",\"name\":\"protocolFeesToken1\",\"type\":\"uint128\"}],\"name\":\"Swap\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"int24\",\"name\":\"tickLower\",\"type\":\"int24\"},{\"internalType\":\"int24\",\"name\":\"tickUpper\",\"type\":\"int24\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"}],\"name\":\"burn\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"int24\",\"name\":\"tickLower\",\"type\":\"int24\"},{\"internalType\":\"int24\",\"name\":\"tickUpper\",\"type\":\"int24\"},{\"internalType\":\"uint128\",\"name\":\"amount0Requested\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"amount1Requested\",\"type\":\"uint128\"}],\"name\":\"collect\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"amount0\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"amount1\",\"type\":\"uint128\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint128\",\"name\":\"amount0Requested\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"amount1Requested\",\"type\":\"uint128\"}],\"name\":\"collectProtocol\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"amount0\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"amount1\",\"type\":\"uint128\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"factory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"fee\",\"outputs\":[{\"internalType\":\"uint24\",\"name\":\"\",\"type\":\"uint24\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"feeGrowthGlobal0X128\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"feeGrowthGlobal1X128\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"flash\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint16\",\"name\":\"observationCardinalityNext\",\"type\":\"uint16\"}],\"name\":\"increaseObservationCardinalityNext\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint160\",\"name\":\"sqrtPriceX96\",\"type\":\"uint160\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"liquidity\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"\",\"type\":\"uint128\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lmPool\",\"outputs\":[{\"internalType\":\"contractIPancakeV3LmPool\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"maxLiquidityPerTick\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"\",\"type\":\"uint128\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"int24\",\"name\":\"tickLower\",\"type\":\"int24\"},{\"internalType\":\"int24\",\"name\":\"tickUpper\",\"type\":\"int24\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"mint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"observations\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"blockTimestamp\",\"type\":\"uint32\"},{\"internalType\":\"int56\",\"name\":\"tickCumulative\",\"type\":\"int56\"},{\"internalType\":\"uint160\",\"name\":\"secondsPerLiquidityCumulativeX128\",\"type\":\"uint160\"},{\"internalType\":\"bool\",\"name\":\"initialized\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32[]\",\"name\":\"secondsAgos\",\"type\":\"uint32[]\"}],\"name\":\"observe\",\"outputs\":[{\"internalType\":\"int56[]\",\"name\":\"tickCumulatives\",\"type\":\"int56[]\"},{\"internalType\":\"uint160[]\",\"name\":\"secondsPerLiquidityCumulativeX128s\",\"type\":\"uint160[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"positions\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"liquidity\",\"type\":\"uint128\"},{\"internalType\":\"uint256\",\"name\":\"feeGrowthInside0LastX128\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeGrowthInside1LastX128\",\"type\":\"uint256\"},{\"internalType\":\"uint128\",\"name\":\"tokensOwed0\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"tokensOwed1\",\"type\":\"uint128\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"protocolFees\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"token0\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"token1\",\"type\":\"uint128\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"feeProtocol0\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"feeProtocol1\",\"type\":\"uint32\"}],\"name\":\"setFeeProtocol\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_lmPool\",\"type\":\"address\"}],\"name\":\"setLmPool\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"slot0\",\"outputs\":[{\"internalType\":\"uint160\",\"name\":\"sqrtPriceX96\",\"type\":\"uint160\"},{\"internalType\":\"int24\",\"name\":\"tick\",\"type\":\"int24\"},{\"internalType\":\"uint16\",\"name\":\"observationIndex\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"observationCardinality\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"observationCardinalityNext\",\"type\":\"uint16\"},{\"internalType\":\"uint32\",\"name\":\"feeProtocol\",\"type\":\"uint32\"},{\"internalType\":\"bool\",\"name\":\"unlocked\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int24\",\"name\":\"tickLower\",\"type\":\"int24\"},{\"internalType\":\"int24\",\"name\":\"tickUpper\",\"type\":\"int24\"}],\"name\":\"snapshotCumulativesInside\",\"outputs\":[{\"internalType\":\"int56\",\"name\":\"tickCumulativeInside\",\"type\":\"int56\"},{\"internalType\":\"uint160\",\"name\":\"secondsPerLiquidityInsideX128\",\"type\":\"uint160\"},{\"internalType\":\"uint32\",\"name\":\"secondsInside\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"zeroForOne\",\"type\":\"bool\"},{\"internalType\":\"int256\",\"name\":\"amountSpecified\",\"type\":\"int256\"},{\"internalType\":\"uint160\",\"name\":\"sqrtPriceLimitX96\",\"type\":\"uint160\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"swap\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"amount0\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"amount1\",\"type\":\"int256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int16\",\"name\":\"\",\"type\":\"int16\"}],\"name\":\"tickBitmap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tickSpacing\",\"outputs\":[{\"internalType\":\"int24\",\"name\":\"\",\"type\":\"int24\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int24\",\"name\":\"\",\"type\":\"int24\"}],\"name\":\"ticks\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"liquidityGross\",\"type\":\"uint128\"},{\"internalType\":\"int128\",\"name\":\"liquidityNet\",\"type\":\"int128\"},{\"internalType\":\"uint256\",\"name\":\"feeGrowthOutside0X128\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feeGrowthOutside1X128\",\"type\":\"uint256\"},{\"internalType\":\"int56\",\"name\":\"tickCumulativeOutside\",\"type\":\"int56\"},{\"internalType\":\"uint160\",\"name\":\"secondsPerLiquidityOutsideX128\",\"type\":\"uint160\"},{\"internalType\":\"uint32\",\"name\":\"secondsOutside\",\"type\":\"uint32\"},{\"internalType\":\"bool\",\"name\":\"initialized\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"token0\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"token1\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", 35 } 36 37 // Pancakev3pairABI is the input ABI used to generate the binding from. 38 // Deprecated: Use Pancakev3pairMetaData.ABI instead. 39 var Pancakev3pairABI = Pancakev3pairMetaData.ABI 40 41 // Pancakev3pair is an auto generated Go binding around an Ethereum contract. 42 type Pancakev3pair struct { 43 Pancakev3pairCaller // Read-only binding to the contract 44 Pancakev3pairTransactor // Write-only binding to the contract 45 Pancakev3pairFilterer // Log filterer for contract events 46 } 47 48 // Pancakev3pairCaller is an auto generated read-only Go binding around an Ethereum contract. 49 type Pancakev3pairCaller struct { 50 contract *bind.BoundContract // Generic contract wrapper for the low level calls 51 } 52 53 // Pancakev3pairTransactor is an auto generated write-only Go binding around an Ethereum contract. 54 type Pancakev3pairTransactor struct { 55 contract *bind.BoundContract // Generic contract wrapper for the low level calls 56 } 57 58 // Pancakev3pairFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 59 type Pancakev3pairFilterer struct { 60 contract *bind.BoundContract // Generic contract wrapper for the low level calls 61 } 62 63 // Pancakev3pairSession is an auto generated Go binding around an Ethereum contract, 64 // with pre-set call and transact options. 65 type Pancakev3pairSession struct { 66 Contract *Pancakev3pair // Generic contract binding to set the session for 67 CallOpts bind.CallOpts // Call options to use throughout this session 68 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 69 } 70 71 // Pancakev3pairCallerSession is an auto generated read-only Go binding around an Ethereum contract, 72 // with pre-set call options. 73 type Pancakev3pairCallerSession struct { 74 Contract *Pancakev3pairCaller // Generic contract caller binding to set the session for 75 CallOpts bind.CallOpts // Call options to use throughout this session 76 } 77 78 // Pancakev3pairTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 79 // with pre-set transact options. 80 type Pancakev3pairTransactorSession struct { 81 Contract *Pancakev3pairTransactor // Generic contract transactor binding to set the session for 82 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 83 } 84 85 // Pancakev3pairRaw is an auto generated low-level Go binding around an Ethereum contract. 86 type Pancakev3pairRaw struct { 87 Contract *Pancakev3pair // Generic contract binding to access the raw methods on 88 } 89 90 // Pancakev3pairCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 91 type Pancakev3pairCallerRaw struct { 92 Contract *Pancakev3pairCaller // Generic read-only contract binding to access the raw methods on 93 } 94 95 // Pancakev3pairTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 96 type Pancakev3pairTransactorRaw struct { 97 Contract *Pancakev3pairTransactor // Generic write-only contract binding to access the raw methods on 98 } 99 100 // NewPancakev3pair creates a new instance of Pancakev3pair, bound to a specific deployed contract. 101 func NewPancakev3pair(address common.Address, backend bind.ContractBackend) (*Pancakev3pair, error) { 102 contract, err := bindPancakev3pair(address, backend, backend, backend) 103 if err != nil { 104 return nil, err 105 } 106 return &Pancakev3pair{Pancakev3pairCaller: Pancakev3pairCaller{contract: contract}, Pancakev3pairTransactor: Pancakev3pairTransactor{contract: contract}, Pancakev3pairFilterer: Pancakev3pairFilterer{contract: contract}}, nil 107 } 108 109 // NewPancakev3pairCaller creates a new read-only instance of Pancakev3pair, bound to a specific deployed contract. 110 func NewPancakev3pairCaller(address common.Address, caller bind.ContractCaller) (*Pancakev3pairCaller, error) { 111 contract, err := bindPancakev3pair(address, caller, nil, nil) 112 if err != nil { 113 return nil, err 114 } 115 return &Pancakev3pairCaller{contract: contract}, nil 116 } 117 118 // NewPancakev3pairTransactor creates a new write-only instance of Pancakev3pair, bound to a specific deployed contract. 119 func NewPancakev3pairTransactor(address common.Address, transactor bind.ContractTransactor) (*Pancakev3pairTransactor, error) { 120 contract, err := bindPancakev3pair(address, nil, transactor, nil) 121 if err != nil { 122 return nil, err 123 } 124 return &Pancakev3pairTransactor{contract: contract}, nil 125 } 126 127 // NewPancakev3pairFilterer creates a new log filterer instance of Pancakev3pair, bound to a specific deployed contract. 128 func NewPancakev3pairFilterer(address common.Address, filterer bind.ContractFilterer) (*Pancakev3pairFilterer, error) { 129 contract, err := bindPancakev3pair(address, nil, nil, filterer) 130 if err != nil { 131 return nil, err 132 } 133 return &Pancakev3pairFilterer{contract: contract}, nil 134 } 135 136 // bindPancakev3pair binds a generic wrapper to an already deployed contract. 137 func bindPancakev3pair(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 138 parsed, err := Pancakev3pairMetaData.GetAbi() 139 if err != nil { 140 return nil, err 141 } 142 return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil 143 } 144 145 // Call invokes the (constant) contract method with params as input values and 146 // sets the output to result. The result type might be a single field for simple 147 // returns, a slice of interfaces for anonymous returns and a struct for named 148 // returns. 149 func (_Pancakev3pair *Pancakev3pairRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { 150 return _Pancakev3pair.Contract.Pancakev3pairCaller.contract.Call(opts, result, method, params...) 151 } 152 153 // Transfer initiates a plain transaction to move funds to the contract, calling 154 // its default method if one is available. 155 func (_Pancakev3pair *Pancakev3pairRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 156 return _Pancakev3pair.Contract.Pancakev3pairTransactor.contract.Transfer(opts) 157 } 158 159 // Transact invokes the (paid) contract method with params as input values. 160 func (_Pancakev3pair *Pancakev3pairRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 161 return _Pancakev3pair.Contract.Pancakev3pairTransactor.contract.Transact(opts, method, params...) 162 } 163 164 // Call invokes the (constant) contract method with params as input values and 165 // sets the output to result. The result type might be a single field for simple 166 // returns, a slice of interfaces for anonymous returns and a struct for named 167 // returns. 168 func (_Pancakev3pair *Pancakev3pairCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { 169 return _Pancakev3pair.Contract.contract.Call(opts, result, method, params...) 170 } 171 172 // Transfer initiates a plain transaction to move funds to the contract, calling 173 // its default method if one is available. 174 func (_Pancakev3pair *Pancakev3pairTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 175 return _Pancakev3pair.Contract.contract.Transfer(opts) 176 } 177 178 // Transact invokes the (paid) contract method with params as input values. 179 func (_Pancakev3pair *Pancakev3pairTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 180 return _Pancakev3pair.Contract.contract.Transact(opts, method, params...) 181 } 182 183 // Factory is a free data retrieval call binding the contract method 0xc45a0155. 184 // 185 // Solidity: function factory() view returns(address) 186 func (_Pancakev3pair *Pancakev3pairCaller) Factory(opts *bind.CallOpts) (common.Address, error) { 187 var out []interface{} 188 err := _Pancakev3pair.contract.Call(opts, &out, "factory") 189 190 if err != nil { 191 return *new(common.Address), err 192 } 193 194 out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) 195 196 return out0, err 197 198 } 199 200 // Factory is a free data retrieval call binding the contract method 0xc45a0155. 201 // 202 // Solidity: function factory() view returns(address) 203 func (_Pancakev3pair *Pancakev3pairSession) Factory() (common.Address, error) { 204 return _Pancakev3pair.Contract.Factory(&_Pancakev3pair.CallOpts) 205 } 206 207 // Factory is a free data retrieval call binding the contract method 0xc45a0155. 208 // 209 // Solidity: function factory() view returns(address) 210 func (_Pancakev3pair *Pancakev3pairCallerSession) Factory() (common.Address, error) { 211 return _Pancakev3pair.Contract.Factory(&_Pancakev3pair.CallOpts) 212 } 213 214 // Fee is a free data retrieval call binding the contract method 0xddca3f43. 215 // 216 // Solidity: function fee() view returns(uint24) 217 func (_Pancakev3pair *Pancakev3pairCaller) Fee(opts *bind.CallOpts) (*big.Int, error) { 218 var out []interface{} 219 err := _Pancakev3pair.contract.Call(opts, &out, "fee") 220 221 if err != nil { 222 return *new(*big.Int), err 223 } 224 225 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 226 227 return out0, err 228 229 } 230 231 // Fee is a free data retrieval call binding the contract method 0xddca3f43. 232 // 233 // Solidity: function fee() view returns(uint24) 234 func (_Pancakev3pair *Pancakev3pairSession) Fee() (*big.Int, error) { 235 return _Pancakev3pair.Contract.Fee(&_Pancakev3pair.CallOpts) 236 } 237 238 // Fee is a free data retrieval call binding the contract method 0xddca3f43. 239 // 240 // Solidity: function fee() view returns(uint24) 241 func (_Pancakev3pair *Pancakev3pairCallerSession) Fee() (*big.Int, error) { 242 return _Pancakev3pair.Contract.Fee(&_Pancakev3pair.CallOpts) 243 } 244 245 // FeeGrowthGlobal0X128 is a free data retrieval call binding the contract method 0xf3058399. 246 // 247 // Solidity: function feeGrowthGlobal0X128() view returns(uint256) 248 func (_Pancakev3pair *Pancakev3pairCaller) FeeGrowthGlobal0X128(opts *bind.CallOpts) (*big.Int, error) { 249 var out []interface{} 250 err := _Pancakev3pair.contract.Call(opts, &out, "feeGrowthGlobal0X128") 251 252 if err != nil { 253 return *new(*big.Int), err 254 } 255 256 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 257 258 return out0, err 259 260 } 261 262 // FeeGrowthGlobal0X128 is a free data retrieval call binding the contract method 0xf3058399. 263 // 264 // Solidity: function feeGrowthGlobal0X128() view returns(uint256) 265 func (_Pancakev3pair *Pancakev3pairSession) FeeGrowthGlobal0X128() (*big.Int, error) { 266 return _Pancakev3pair.Contract.FeeGrowthGlobal0X128(&_Pancakev3pair.CallOpts) 267 } 268 269 // FeeGrowthGlobal0X128 is a free data retrieval call binding the contract method 0xf3058399. 270 // 271 // Solidity: function feeGrowthGlobal0X128() view returns(uint256) 272 func (_Pancakev3pair *Pancakev3pairCallerSession) FeeGrowthGlobal0X128() (*big.Int, error) { 273 return _Pancakev3pair.Contract.FeeGrowthGlobal0X128(&_Pancakev3pair.CallOpts) 274 } 275 276 // FeeGrowthGlobal1X128 is a free data retrieval call binding the contract method 0x46141319. 277 // 278 // Solidity: function feeGrowthGlobal1X128() view returns(uint256) 279 func (_Pancakev3pair *Pancakev3pairCaller) FeeGrowthGlobal1X128(opts *bind.CallOpts) (*big.Int, error) { 280 var out []interface{} 281 err := _Pancakev3pair.contract.Call(opts, &out, "feeGrowthGlobal1X128") 282 283 if err != nil { 284 return *new(*big.Int), err 285 } 286 287 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 288 289 return out0, err 290 291 } 292 293 // FeeGrowthGlobal1X128 is a free data retrieval call binding the contract method 0x46141319. 294 // 295 // Solidity: function feeGrowthGlobal1X128() view returns(uint256) 296 func (_Pancakev3pair *Pancakev3pairSession) FeeGrowthGlobal1X128() (*big.Int, error) { 297 return _Pancakev3pair.Contract.FeeGrowthGlobal1X128(&_Pancakev3pair.CallOpts) 298 } 299 300 // FeeGrowthGlobal1X128 is a free data retrieval call binding the contract method 0x46141319. 301 // 302 // Solidity: function feeGrowthGlobal1X128() view returns(uint256) 303 func (_Pancakev3pair *Pancakev3pairCallerSession) FeeGrowthGlobal1X128() (*big.Int, error) { 304 return _Pancakev3pair.Contract.FeeGrowthGlobal1X128(&_Pancakev3pair.CallOpts) 305 } 306 307 // Liquidity is a free data retrieval call binding the contract method 0x1a686502. 308 // 309 // Solidity: function liquidity() view returns(uint128) 310 func (_Pancakev3pair *Pancakev3pairCaller) Liquidity(opts *bind.CallOpts) (*big.Int, error) { 311 var out []interface{} 312 err := _Pancakev3pair.contract.Call(opts, &out, "liquidity") 313 314 if err != nil { 315 return *new(*big.Int), err 316 } 317 318 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 319 320 return out0, err 321 322 } 323 324 // Liquidity is a free data retrieval call binding the contract method 0x1a686502. 325 // 326 // Solidity: function liquidity() view returns(uint128) 327 func (_Pancakev3pair *Pancakev3pairSession) Liquidity() (*big.Int, error) { 328 return _Pancakev3pair.Contract.Liquidity(&_Pancakev3pair.CallOpts) 329 } 330 331 // Liquidity is a free data retrieval call binding the contract method 0x1a686502. 332 // 333 // Solidity: function liquidity() view returns(uint128) 334 func (_Pancakev3pair *Pancakev3pairCallerSession) Liquidity() (*big.Int, error) { 335 return _Pancakev3pair.Contract.Liquidity(&_Pancakev3pair.CallOpts) 336 } 337 338 // LmPool is a free data retrieval call binding the contract method 0x540d4918. 339 // 340 // Solidity: function lmPool() view returns(address) 341 func (_Pancakev3pair *Pancakev3pairCaller) LmPool(opts *bind.CallOpts) (common.Address, error) { 342 var out []interface{} 343 err := _Pancakev3pair.contract.Call(opts, &out, "lmPool") 344 345 if err != nil { 346 return *new(common.Address), err 347 } 348 349 out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) 350 351 return out0, err 352 353 } 354 355 // LmPool is a free data retrieval call binding the contract method 0x540d4918. 356 // 357 // Solidity: function lmPool() view returns(address) 358 func (_Pancakev3pair *Pancakev3pairSession) LmPool() (common.Address, error) { 359 return _Pancakev3pair.Contract.LmPool(&_Pancakev3pair.CallOpts) 360 } 361 362 // LmPool is a free data retrieval call binding the contract method 0x540d4918. 363 // 364 // Solidity: function lmPool() view returns(address) 365 func (_Pancakev3pair *Pancakev3pairCallerSession) LmPool() (common.Address, error) { 366 return _Pancakev3pair.Contract.LmPool(&_Pancakev3pair.CallOpts) 367 } 368 369 // MaxLiquidityPerTick is a free data retrieval call binding the contract method 0x70cf754a. 370 // 371 // Solidity: function maxLiquidityPerTick() view returns(uint128) 372 func (_Pancakev3pair *Pancakev3pairCaller) MaxLiquidityPerTick(opts *bind.CallOpts) (*big.Int, error) { 373 var out []interface{} 374 err := _Pancakev3pair.contract.Call(opts, &out, "maxLiquidityPerTick") 375 376 if err != nil { 377 return *new(*big.Int), err 378 } 379 380 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 381 382 return out0, err 383 384 } 385 386 // MaxLiquidityPerTick is a free data retrieval call binding the contract method 0x70cf754a. 387 // 388 // Solidity: function maxLiquidityPerTick() view returns(uint128) 389 func (_Pancakev3pair *Pancakev3pairSession) MaxLiquidityPerTick() (*big.Int, error) { 390 return _Pancakev3pair.Contract.MaxLiquidityPerTick(&_Pancakev3pair.CallOpts) 391 } 392 393 // MaxLiquidityPerTick is a free data retrieval call binding the contract method 0x70cf754a. 394 // 395 // Solidity: function maxLiquidityPerTick() view returns(uint128) 396 func (_Pancakev3pair *Pancakev3pairCallerSession) MaxLiquidityPerTick() (*big.Int, error) { 397 return _Pancakev3pair.Contract.MaxLiquidityPerTick(&_Pancakev3pair.CallOpts) 398 } 399 400 // Observations is a free data retrieval call binding the contract method 0x252c09d7. 401 // 402 // Solidity: function observations(uint256 ) view returns(uint32 blockTimestamp, int56 tickCumulative, uint160 secondsPerLiquidityCumulativeX128, bool initialized) 403 func (_Pancakev3pair *Pancakev3pairCaller) Observations(opts *bind.CallOpts, arg0 *big.Int) (struct { 404 BlockTimestamp uint32 405 TickCumulative *big.Int 406 SecondsPerLiquidityCumulativeX128 *big.Int 407 Initialized bool 408 }, error) { 409 var out []interface{} 410 err := _Pancakev3pair.contract.Call(opts, &out, "observations", arg0) 411 412 outstruct := new(struct { 413 BlockTimestamp uint32 414 TickCumulative *big.Int 415 SecondsPerLiquidityCumulativeX128 *big.Int 416 Initialized bool 417 }) 418 if err != nil { 419 return *outstruct, err 420 } 421 422 outstruct.BlockTimestamp = *abi.ConvertType(out[0], new(uint32)).(*uint32) 423 outstruct.TickCumulative = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) 424 outstruct.SecondsPerLiquidityCumulativeX128 = *abi.ConvertType(out[2], new(*big.Int)).(**big.Int) 425 outstruct.Initialized = *abi.ConvertType(out[3], new(bool)).(*bool) 426 427 return *outstruct, err 428 429 } 430 431 // Observations is a free data retrieval call binding the contract method 0x252c09d7. 432 // 433 // Solidity: function observations(uint256 ) view returns(uint32 blockTimestamp, int56 tickCumulative, uint160 secondsPerLiquidityCumulativeX128, bool initialized) 434 func (_Pancakev3pair *Pancakev3pairSession) Observations(arg0 *big.Int) (struct { 435 BlockTimestamp uint32 436 TickCumulative *big.Int 437 SecondsPerLiquidityCumulativeX128 *big.Int 438 Initialized bool 439 }, error) { 440 return _Pancakev3pair.Contract.Observations(&_Pancakev3pair.CallOpts, arg0) 441 } 442 443 // Observations is a free data retrieval call binding the contract method 0x252c09d7. 444 // 445 // Solidity: function observations(uint256 ) view returns(uint32 blockTimestamp, int56 tickCumulative, uint160 secondsPerLiquidityCumulativeX128, bool initialized) 446 func (_Pancakev3pair *Pancakev3pairCallerSession) Observations(arg0 *big.Int) (struct { 447 BlockTimestamp uint32 448 TickCumulative *big.Int 449 SecondsPerLiquidityCumulativeX128 *big.Int 450 Initialized bool 451 }, error) { 452 return _Pancakev3pair.Contract.Observations(&_Pancakev3pair.CallOpts, arg0) 453 } 454 455 // Observe is a free data retrieval call binding the contract method 0x883bdbfd. 456 // 457 // Solidity: function observe(uint32[] secondsAgos) view returns(int56[] tickCumulatives, uint160[] secondsPerLiquidityCumulativeX128s) 458 func (_Pancakev3pair *Pancakev3pairCaller) Observe(opts *bind.CallOpts, secondsAgos []uint32) (struct { 459 TickCumulatives []*big.Int 460 SecondsPerLiquidityCumulativeX128s []*big.Int 461 }, error) { 462 var out []interface{} 463 err := _Pancakev3pair.contract.Call(opts, &out, "observe", secondsAgos) 464 465 outstruct := new(struct { 466 TickCumulatives []*big.Int 467 SecondsPerLiquidityCumulativeX128s []*big.Int 468 }) 469 if err != nil { 470 return *outstruct, err 471 } 472 473 outstruct.TickCumulatives = *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) 474 outstruct.SecondsPerLiquidityCumulativeX128s = *abi.ConvertType(out[1], new([]*big.Int)).(*[]*big.Int) 475 476 return *outstruct, err 477 478 } 479 480 // Observe is a free data retrieval call binding the contract method 0x883bdbfd. 481 // 482 // Solidity: function observe(uint32[] secondsAgos) view returns(int56[] tickCumulatives, uint160[] secondsPerLiquidityCumulativeX128s) 483 func (_Pancakev3pair *Pancakev3pairSession) Observe(secondsAgos []uint32) (struct { 484 TickCumulatives []*big.Int 485 SecondsPerLiquidityCumulativeX128s []*big.Int 486 }, error) { 487 return _Pancakev3pair.Contract.Observe(&_Pancakev3pair.CallOpts, secondsAgos) 488 } 489 490 // Observe is a free data retrieval call binding the contract method 0x883bdbfd. 491 // 492 // Solidity: function observe(uint32[] secondsAgos) view returns(int56[] tickCumulatives, uint160[] secondsPerLiquidityCumulativeX128s) 493 func (_Pancakev3pair *Pancakev3pairCallerSession) Observe(secondsAgos []uint32) (struct { 494 TickCumulatives []*big.Int 495 SecondsPerLiquidityCumulativeX128s []*big.Int 496 }, error) { 497 return _Pancakev3pair.Contract.Observe(&_Pancakev3pair.CallOpts, secondsAgos) 498 } 499 500 // Positions is a free data retrieval call binding the contract method 0x514ea4bf. 501 // 502 // Solidity: function positions(bytes32 ) view returns(uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128, uint128 tokensOwed0, uint128 tokensOwed1) 503 func (_Pancakev3pair *Pancakev3pairCaller) Positions(opts *bind.CallOpts, arg0 [32]byte) (struct { 504 Liquidity *big.Int 505 FeeGrowthInside0LastX128 *big.Int 506 FeeGrowthInside1LastX128 *big.Int 507 TokensOwed0 *big.Int 508 TokensOwed1 *big.Int 509 }, error) { 510 var out []interface{} 511 err := _Pancakev3pair.contract.Call(opts, &out, "positions", arg0) 512 513 outstruct := new(struct { 514 Liquidity *big.Int 515 FeeGrowthInside0LastX128 *big.Int 516 FeeGrowthInside1LastX128 *big.Int 517 TokensOwed0 *big.Int 518 TokensOwed1 *big.Int 519 }) 520 if err != nil { 521 return *outstruct, err 522 } 523 524 outstruct.Liquidity = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 525 outstruct.FeeGrowthInside0LastX128 = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) 526 outstruct.FeeGrowthInside1LastX128 = *abi.ConvertType(out[2], new(*big.Int)).(**big.Int) 527 outstruct.TokensOwed0 = *abi.ConvertType(out[3], new(*big.Int)).(**big.Int) 528 outstruct.TokensOwed1 = *abi.ConvertType(out[4], new(*big.Int)).(**big.Int) 529 530 return *outstruct, err 531 532 } 533 534 // Positions is a free data retrieval call binding the contract method 0x514ea4bf. 535 // 536 // Solidity: function positions(bytes32 ) view returns(uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128, uint128 tokensOwed0, uint128 tokensOwed1) 537 func (_Pancakev3pair *Pancakev3pairSession) Positions(arg0 [32]byte) (struct { 538 Liquidity *big.Int 539 FeeGrowthInside0LastX128 *big.Int 540 FeeGrowthInside1LastX128 *big.Int 541 TokensOwed0 *big.Int 542 TokensOwed1 *big.Int 543 }, error) { 544 return _Pancakev3pair.Contract.Positions(&_Pancakev3pair.CallOpts, arg0) 545 } 546 547 // Positions is a free data retrieval call binding the contract method 0x514ea4bf. 548 // 549 // Solidity: function positions(bytes32 ) view returns(uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128, uint128 tokensOwed0, uint128 tokensOwed1) 550 func (_Pancakev3pair *Pancakev3pairCallerSession) Positions(arg0 [32]byte) (struct { 551 Liquidity *big.Int 552 FeeGrowthInside0LastX128 *big.Int 553 FeeGrowthInside1LastX128 *big.Int 554 TokensOwed0 *big.Int 555 TokensOwed1 *big.Int 556 }, error) { 557 return _Pancakev3pair.Contract.Positions(&_Pancakev3pair.CallOpts, arg0) 558 } 559 560 // ProtocolFees is a free data retrieval call binding the contract method 0x1ad8b03b. 561 // 562 // Solidity: function protocolFees() view returns(uint128 token0, uint128 token1) 563 func (_Pancakev3pair *Pancakev3pairCaller) ProtocolFees(opts *bind.CallOpts) (struct { 564 Token0 *big.Int 565 Token1 *big.Int 566 }, error) { 567 var out []interface{} 568 err := _Pancakev3pair.contract.Call(opts, &out, "protocolFees") 569 570 outstruct := new(struct { 571 Token0 *big.Int 572 Token1 *big.Int 573 }) 574 if err != nil { 575 return *outstruct, err 576 } 577 578 outstruct.Token0 = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 579 outstruct.Token1 = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) 580 581 return *outstruct, err 582 583 } 584 585 // ProtocolFees is a free data retrieval call binding the contract method 0x1ad8b03b. 586 // 587 // Solidity: function protocolFees() view returns(uint128 token0, uint128 token1) 588 func (_Pancakev3pair *Pancakev3pairSession) ProtocolFees() (struct { 589 Token0 *big.Int 590 Token1 *big.Int 591 }, error) { 592 return _Pancakev3pair.Contract.ProtocolFees(&_Pancakev3pair.CallOpts) 593 } 594 595 // ProtocolFees is a free data retrieval call binding the contract method 0x1ad8b03b. 596 // 597 // Solidity: function protocolFees() view returns(uint128 token0, uint128 token1) 598 func (_Pancakev3pair *Pancakev3pairCallerSession) ProtocolFees() (struct { 599 Token0 *big.Int 600 Token1 *big.Int 601 }, error) { 602 return _Pancakev3pair.Contract.ProtocolFees(&_Pancakev3pair.CallOpts) 603 } 604 605 // Slot0 is a free data retrieval call binding the contract method 0x3850c7bd. 606 // 607 // Solidity: function slot0() view returns(uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint32 feeProtocol, bool unlocked) 608 func (_Pancakev3pair *Pancakev3pairCaller) Slot0(opts *bind.CallOpts) (struct { 609 SqrtPriceX96 *big.Int 610 Tick *big.Int 611 ObservationIndex uint16 612 ObservationCardinality uint16 613 ObservationCardinalityNext uint16 614 FeeProtocol uint32 615 Unlocked bool 616 }, error) { 617 var out []interface{} 618 err := _Pancakev3pair.contract.Call(opts, &out, "slot0") 619 620 outstruct := new(struct { 621 SqrtPriceX96 *big.Int 622 Tick *big.Int 623 ObservationIndex uint16 624 ObservationCardinality uint16 625 ObservationCardinalityNext uint16 626 FeeProtocol uint32 627 Unlocked bool 628 }) 629 if err != nil { 630 return *outstruct, err 631 } 632 633 outstruct.SqrtPriceX96 = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 634 outstruct.Tick = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) 635 outstruct.ObservationIndex = *abi.ConvertType(out[2], new(uint16)).(*uint16) 636 outstruct.ObservationCardinality = *abi.ConvertType(out[3], new(uint16)).(*uint16) 637 outstruct.ObservationCardinalityNext = *abi.ConvertType(out[4], new(uint16)).(*uint16) 638 outstruct.FeeProtocol = *abi.ConvertType(out[5], new(uint32)).(*uint32) 639 outstruct.Unlocked = *abi.ConvertType(out[6], new(bool)).(*bool) 640 641 return *outstruct, err 642 643 } 644 645 // Slot0 is a free data retrieval call binding the contract method 0x3850c7bd. 646 // 647 // Solidity: function slot0() view returns(uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint32 feeProtocol, bool unlocked) 648 func (_Pancakev3pair *Pancakev3pairSession) Slot0() (struct { 649 SqrtPriceX96 *big.Int 650 Tick *big.Int 651 ObservationIndex uint16 652 ObservationCardinality uint16 653 ObservationCardinalityNext uint16 654 FeeProtocol uint32 655 Unlocked bool 656 }, error) { 657 return _Pancakev3pair.Contract.Slot0(&_Pancakev3pair.CallOpts) 658 } 659 660 // Slot0 is a free data retrieval call binding the contract method 0x3850c7bd. 661 // 662 // Solidity: function slot0() view returns(uint160 sqrtPriceX96, int24 tick, uint16 observationIndex, uint16 observationCardinality, uint16 observationCardinalityNext, uint32 feeProtocol, bool unlocked) 663 func (_Pancakev3pair *Pancakev3pairCallerSession) Slot0() (struct { 664 SqrtPriceX96 *big.Int 665 Tick *big.Int 666 ObservationIndex uint16 667 ObservationCardinality uint16 668 ObservationCardinalityNext uint16 669 FeeProtocol uint32 670 Unlocked bool 671 }, error) { 672 return _Pancakev3pair.Contract.Slot0(&_Pancakev3pair.CallOpts) 673 } 674 675 // SnapshotCumulativesInside is a free data retrieval call binding the contract method 0xa38807f2. 676 // 677 // Solidity: function snapshotCumulativesInside(int24 tickLower, int24 tickUpper) view returns(int56 tickCumulativeInside, uint160 secondsPerLiquidityInsideX128, uint32 secondsInside) 678 func (_Pancakev3pair *Pancakev3pairCaller) SnapshotCumulativesInside(opts *bind.CallOpts, tickLower *big.Int, tickUpper *big.Int) (struct { 679 TickCumulativeInside *big.Int 680 SecondsPerLiquidityInsideX128 *big.Int 681 SecondsInside uint32 682 }, error) { 683 var out []interface{} 684 err := _Pancakev3pair.contract.Call(opts, &out, "snapshotCumulativesInside", tickLower, tickUpper) 685 686 outstruct := new(struct { 687 TickCumulativeInside *big.Int 688 SecondsPerLiquidityInsideX128 *big.Int 689 SecondsInside uint32 690 }) 691 if err != nil { 692 return *outstruct, err 693 } 694 695 outstruct.TickCumulativeInside = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 696 outstruct.SecondsPerLiquidityInsideX128 = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) 697 outstruct.SecondsInside = *abi.ConvertType(out[2], new(uint32)).(*uint32) 698 699 return *outstruct, err 700 701 } 702 703 // SnapshotCumulativesInside is a free data retrieval call binding the contract method 0xa38807f2. 704 // 705 // Solidity: function snapshotCumulativesInside(int24 tickLower, int24 tickUpper) view returns(int56 tickCumulativeInside, uint160 secondsPerLiquidityInsideX128, uint32 secondsInside) 706 func (_Pancakev3pair *Pancakev3pairSession) SnapshotCumulativesInside(tickLower *big.Int, tickUpper *big.Int) (struct { 707 TickCumulativeInside *big.Int 708 SecondsPerLiquidityInsideX128 *big.Int 709 SecondsInside uint32 710 }, error) { 711 return _Pancakev3pair.Contract.SnapshotCumulativesInside(&_Pancakev3pair.CallOpts, tickLower, tickUpper) 712 } 713 714 // SnapshotCumulativesInside is a free data retrieval call binding the contract method 0xa38807f2. 715 // 716 // Solidity: function snapshotCumulativesInside(int24 tickLower, int24 tickUpper) view returns(int56 tickCumulativeInside, uint160 secondsPerLiquidityInsideX128, uint32 secondsInside) 717 func (_Pancakev3pair *Pancakev3pairCallerSession) SnapshotCumulativesInside(tickLower *big.Int, tickUpper *big.Int) (struct { 718 TickCumulativeInside *big.Int 719 SecondsPerLiquidityInsideX128 *big.Int 720 SecondsInside uint32 721 }, error) { 722 return _Pancakev3pair.Contract.SnapshotCumulativesInside(&_Pancakev3pair.CallOpts, tickLower, tickUpper) 723 } 724 725 // TickBitmap is a free data retrieval call binding the contract method 0x5339c296. 726 // 727 // Solidity: function tickBitmap(int16 ) view returns(uint256) 728 func (_Pancakev3pair *Pancakev3pairCaller) TickBitmap(opts *bind.CallOpts, arg0 int16) (*big.Int, error) { 729 var out []interface{} 730 err := _Pancakev3pair.contract.Call(opts, &out, "tickBitmap", arg0) 731 732 if err != nil { 733 return *new(*big.Int), err 734 } 735 736 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 737 738 return out0, err 739 740 } 741 742 // TickBitmap is a free data retrieval call binding the contract method 0x5339c296. 743 // 744 // Solidity: function tickBitmap(int16 ) view returns(uint256) 745 func (_Pancakev3pair *Pancakev3pairSession) TickBitmap(arg0 int16) (*big.Int, error) { 746 return _Pancakev3pair.Contract.TickBitmap(&_Pancakev3pair.CallOpts, arg0) 747 } 748 749 // TickBitmap is a free data retrieval call binding the contract method 0x5339c296. 750 // 751 // Solidity: function tickBitmap(int16 ) view returns(uint256) 752 func (_Pancakev3pair *Pancakev3pairCallerSession) TickBitmap(arg0 int16) (*big.Int, error) { 753 return _Pancakev3pair.Contract.TickBitmap(&_Pancakev3pair.CallOpts, arg0) 754 } 755 756 // TickSpacing is a free data retrieval call binding the contract method 0xd0c93a7c. 757 // 758 // Solidity: function tickSpacing() view returns(int24) 759 func (_Pancakev3pair *Pancakev3pairCaller) TickSpacing(opts *bind.CallOpts) (*big.Int, error) { 760 var out []interface{} 761 err := _Pancakev3pair.contract.Call(opts, &out, "tickSpacing") 762 763 if err != nil { 764 return *new(*big.Int), err 765 } 766 767 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 768 769 return out0, err 770 771 } 772 773 // TickSpacing is a free data retrieval call binding the contract method 0xd0c93a7c. 774 // 775 // Solidity: function tickSpacing() view returns(int24) 776 func (_Pancakev3pair *Pancakev3pairSession) TickSpacing() (*big.Int, error) { 777 return _Pancakev3pair.Contract.TickSpacing(&_Pancakev3pair.CallOpts) 778 } 779 780 // TickSpacing is a free data retrieval call binding the contract method 0xd0c93a7c. 781 // 782 // Solidity: function tickSpacing() view returns(int24) 783 func (_Pancakev3pair *Pancakev3pairCallerSession) TickSpacing() (*big.Int, error) { 784 return _Pancakev3pair.Contract.TickSpacing(&_Pancakev3pair.CallOpts) 785 } 786 787 // Ticks is a free data retrieval call binding the contract method 0xf30dba93. 788 // 789 // Solidity: function ticks(int24 ) view returns(uint128 liquidityGross, int128 liquidityNet, uint256 feeGrowthOutside0X128, uint256 feeGrowthOutside1X128, int56 tickCumulativeOutside, uint160 secondsPerLiquidityOutsideX128, uint32 secondsOutside, bool initialized) 790 func (_Pancakev3pair *Pancakev3pairCaller) Ticks(opts *bind.CallOpts, arg0 *big.Int) (struct { 791 LiquidityGross *big.Int 792 LiquidityNet *big.Int 793 FeeGrowthOutside0X128 *big.Int 794 FeeGrowthOutside1X128 *big.Int 795 TickCumulativeOutside *big.Int 796 SecondsPerLiquidityOutsideX128 *big.Int 797 SecondsOutside uint32 798 Initialized bool 799 }, error) { 800 var out []interface{} 801 err := _Pancakev3pair.contract.Call(opts, &out, "ticks", arg0) 802 803 outstruct := new(struct { 804 LiquidityGross *big.Int 805 LiquidityNet *big.Int 806 FeeGrowthOutside0X128 *big.Int 807 FeeGrowthOutside1X128 *big.Int 808 TickCumulativeOutside *big.Int 809 SecondsPerLiquidityOutsideX128 *big.Int 810 SecondsOutside uint32 811 Initialized bool 812 }) 813 if err != nil { 814 return *outstruct, err 815 } 816 817 outstruct.LiquidityGross = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 818 outstruct.LiquidityNet = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) 819 outstruct.FeeGrowthOutside0X128 = *abi.ConvertType(out[2], new(*big.Int)).(**big.Int) 820 outstruct.FeeGrowthOutside1X128 = *abi.ConvertType(out[3], new(*big.Int)).(**big.Int) 821 outstruct.TickCumulativeOutside = *abi.ConvertType(out[4], new(*big.Int)).(**big.Int) 822 outstruct.SecondsPerLiquidityOutsideX128 = *abi.ConvertType(out[5], new(*big.Int)).(**big.Int) 823 outstruct.SecondsOutside = *abi.ConvertType(out[6], new(uint32)).(*uint32) 824 outstruct.Initialized = *abi.ConvertType(out[7], new(bool)).(*bool) 825 826 return *outstruct, err 827 828 } 829 830 // Ticks is a free data retrieval call binding the contract method 0xf30dba93. 831 // 832 // Solidity: function ticks(int24 ) view returns(uint128 liquidityGross, int128 liquidityNet, uint256 feeGrowthOutside0X128, uint256 feeGrowthOutside1X128, int56 tickCumulativeOutside, uint160 secondsPerLiquidityOutsideX128, uint32 secondsOutside, bool initialized) 833 func (_Pancakev3pair *Pancakev3pairSession) Ticks(arg0 *big.Int) (struct { 834 LiquidityGross *big.Int 835 LiquidityNet *big.Int 836 FeeGrowthOutside0X128 *big.Int 837 FeeGrowthOutside1X128 *big.Int 838 TickCumulativeOutside *big.Int 839 SecondsPerLiquidityOutsideX128 *big.Int 840 SecondsOutside uint32 841 Initialized bool 842 }, error) { 843 return _Pancakev3pair.Contract.Ticks(&_Pancakev3pair.CallOpts, arg0) 844 } 845 846 // Ticks is a free data retrieval call binding the contract method 0xf30dba93. 847 // 848 // Solidity: function ticks(int24 ) view returns(uint128 liquidityGross, int128 liquidityNet, uint256 feeGrowthOutside0X128, uint256 feeGrowthOutside1X128, int56 tickCumulativeOutside, uint160 secondsPerLiquidityOutsideX128, uint32 secondsOutside, bool initialized) 849 func (_Pancakev3pair *Pancakev3pairCallerSession) Ticks(arg0 *big.Int) (struct { 850 LiquidityGross *big.Int 851 LiquidityNet *big.Int 852 FeeGrowthOutside0X128 *big.Int 853 FeeGrowthOutside1X128 *big.Int 854 TickCumulativeOutside *big.Int 855 SecondsPerLiquidityOutsideX128 *big.Int 856 SecondsOutside uint32 857 Initialized bool 858 }, error) { 859 return _Pancakev3pair.Contract.Ticks(&_Pancakev3pair.CallOpts, arg0) 860 } 861 862 // Token0 is a free data retrieval call binding the contract method 0x0dfe1681. 863 // 864 // Solidity: function token0() view returns(address) 865 func (_Pancakev3pair *Pancakev3pairCaller) Token0(opts *bind.CallOpts) (common.Address, error) { 866 var out []interface{} 867 err := _Pancakev3pair.contract.Call(opts, &out, "token0") 868 869 if err != nil { 870 return *new(common.Address), err 871 } 872 873 out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) 874 875 return out0, err 876 877 } 878 879 // Token0 is a free data retrieval call binding the contract method 0x0dfe1681. 880 // 881 // Solidity: function token0() view returns(address) 882 func (_Pancakev3pair *Pancakev3pairSession) Token0() (common.Address, error) { 883 return _Pancakev3pair.Contract.Token0(&_Pancakev3pair.CallOpts) 884 } 885 886 // Token0 is a free data retrieval call binding the contract method 0x0dfe1681. 887 // 888 // Solidity: function token0() view returns(address) 889 func (_Pancakev3pair *Pancakev3pairCallerSession) Token0() (common.Address, error) { 890 return _Pancakev3pair.Contract.Token0(&_Pancakev3pair.CallOpts) 891 } 892 893 // Token1 is a free data retrieval call binding the contract method 0xd21220a7. 894 // 895 // Solidity: function token1() view returns(address) 896 func (_Pancakev3pair *Pancakev3pairCaller) Token1(opts *bind.CallOpts) (common.Address, error) { 897 var out []interface{} 898 err := _Pancakev3pair.contract.Call(opts, &out, "token1") 899 900 if err != nil { 901 return *new(common.Address), err 902 } 903 904 out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) 905 906 return out0, err 907 908 } 909 910 // Token1 is a free data retrieval call binding the contract method 0xd21220a7. 911 // 912 // Solidity: function token1() view returns(address) 913 func (_Pancakev3pair *Pancakev3pairSession) Token1() (common.Address, error) { 914 return _Pancakev3pair.Contract.Token1(&_Pancakev3pair.CallOpts) 915 } 916 917 // Token1 is a free data retrieval call binding the contract method 0xd21220a7. 918 // 919 // Solidity: function token1() view returns(address) 920 func (_Pancakev3pair *Pancakev3pairCallerSession) Token1() (common.Address, error) { 921 return _Pancakev3pair.Contract.Token1(&_Pancakev3pair.CallOpts) 922 } 923 924 // Burn is a paid mutator transaction binding the contract method 0xa34123a7. 925 // 926 // Solidity: function burn(int24 tickLower, int24 tickUpper, uint128 amount) returns(uint256 amount0, uint256 amount1) 927 func (_Pancakev3pair *Pancakev3pairTransactor) Burn(opts *bind.TransactOpts, tickLower *big.Int, tickUpper *big.Int, amount *big.Int) (*types.Transaction, error) { 928 return _Pancakev3pair.contract.Transact(opts, "burn", tickLower, tickUpper, amount) 929 } 930 931 // Burn is a paid mutator transaction binding the contract method 0xa34123a7. 932 // 933 // Solidity: function burn(int24 tickLower, int24 tickUpper, uint128 amount) returns(uint256 amount0, uint256 amount1) 934 func (_Pancakev3pair *Pancakev3pairSession) Burn(tickLower *big.Int, tickUpper *big.Int, amount *big.Int) (*types.Transaction, error) { 935 return _Pancakev3pair.Contract.Burn(&_Pancakev3pair.TransactOpts, tickLower, tickUpper, amount) 936 } 937 938 // Burn is a paid mutator transaction binding the contract method 0xa34123a7. 939 // 940 // Solidity: function burn(int24 tickLower, int24 tickUpper, uint128 amount) returns(uint256 amount0, uint256 amount1) 941 func (_Pancakev3pair *Pancakev3pairTransactorSession) Burn(tickLower *big.Int, tickUpper *big.Int, amount *big.Int) (*types.Transaction, error) { 942 return _Pancakev3pair.Contract.Burn(&_Pancakev3pair.TransactOpts, tickLower, tickUpper, amount) 943 } 944 945 // Collect is a paid mutator transaction binding the contract method 0x4f1eb3d8. 946 // 947 // Solidity: function collect(address recipient, int24 tickLower, int24 tickUpper, uint128 amount0Requested, uint128 amount1Requested) returns(uint128 amount0, uint128 amount1) 948 func (_Pancakev3pair *Pancakev3pairTransactor) Collect(opts *bind.TransactOpts, recipient common.Address, tickLower *big.Int, tickUpper *big.Int, amount0Requested *big.Int, amount1Requested *big.Int) (*types.Transaction, error) { 949 return _Pancakev3pair.contract.Transact(opts, "collect", recipient, tickLower, tickUpper, amount0Requested, amount1Requested) 950 } 951 952 // Collect is a paid mutator transaction binding the contract method 0x4f1eb3d8. 953 // 954 // Solidity: function collect(address recipient, int24 tickLower, int24 tickUpper, uint128 amount0Requested, uint128 amount1Requested) returns(uint128 amount0, uint128 amount1) 955 func (_Pancakev3pair *Pancakev3pairSession) Collect(recipient common.Address, tickLower *big.Int, tickUpper *big.Int, amount0Requested *big.Int, amount1Requested *big.Int) (*types.Transaction, error) { 956 return _Pancakev3pair.Contract.Collect(&_Pancakev3pair.TransactOpts, recipient, tickLower, tickUpper, amount0Requested, amount1Requested) 957 } 958 959 // Collect is a paid mutator transaction binding the contract method 0x4f1eb3d8. 960 // 961 // Solidity: function collect(address recipient, int24 tickLower, int24 tickUpper, uint128 amount0Requested, uint128 amount1Requested) returns(uint128 amount0, uint128 amount1) 962 func (_Pancakev3pair *Pancakev3pairTransactorSession) Collect(recipient common.Address, tickLower *big.Int, tickUpper *big.Int, amount0Requested *big.Int, amount1Requested *big.Int) (*types.Transaction, error) { 963 return _Pancakev3pair.Contract.Collect(&_Pancakev3pair.TransactOpts, recipient, tickLower, tickUpper, amount0Requested, amount1Requested) 964 } 965 966 // CollectProtocol is a paid mutator transaction binding the contract method 0x85b66729. 967 // 968 // Solidity: function collectProtocol(address recipient, uint128 amount0Requested, uint128 amount1Requested) returns(uint128 amount0, uint128 amount1) 969 func (_Pancakev3pair *Pancakev3pairTransactor) CollectProtocol(opts *bind.TransactOpts, recipient common.Address, amount0Requested *big.Int, amount1Requested *big.Int) (*types.Transaction, error) { 970 return _Pancakev3pair.contract.Transact(opts, "collectProtocol", recipient, amount0Requested, amount1Requested) 971 } 972 973 // CollectProtocol is a paid mutator transaction binding the contract method 0x85b66729. 974 // 975 // Solidity: function collectProtocol(address recipient, uint128 amount0Requested, uint128 amount1Requested) returns(uint128 amount0, uint128 amount1) 976 func (_Pancakev3pair *Pancakev3pairSession) CollectProtocol(recipient common.Address, amount0Requested *big.Int, amount1Requested *big.Int) (*types.Transaction, error) { 977 return _Pancakev3pair.Contract.CollectProtocol(&_Pancakev3pair.TransactOpts, recipient, amount0Requested, amount1Requested) 978 } 979 980 // CollectProtocol is a paid mutator transaction binding the contract method 0x85b66729. 981 // 982 // Solidity: function collectProtocol(address recipient, uint128 amount0Requested, uint128 amount1Requested) returns(uint128 amount0, uint128 amount1) 983 func (_Pancakev3pair *Pancakev3pairTransactorSession) CollectProtocol(recipient common.Address, amount0Requested *big.Int, amount1Requested *big.Int) (*types.Transaction, error) { 984 return _Pancakev3pair.Contract.CollectProtocol(&_Pancakev3pair.TransactOpts, recipient, amount0Requested, amount1Requested) 985 } 986 987 // Flash is a paid mutator transaction binding the contract method 0x490e6cbc. 988 // 989 // Solidity: function flash(address recipient, uint256 amount0, uint256 amount1, bytes data) returns() 990 func (_Pancakev3pair *Pancakev3pairTransactor) Flash(opts *bind.TransactOpts, recipient common.Address, amount0 *big.Int, amount1 *big.Int, data []byte) (*types.Transaction, error) { 991 return _Pancakev3pair.contract.Transact(opts, "flash", recipient, amount0, amount1, data) 992 } 993 994 // Flash is a paid mutator transaction binding the contract method 0x490e6cbc. 995 // 996 // Solidity: function flash(address recipient, uint256 amount0, uint256 amount1, bytes data) returns() 997 func (_Pancakev3pair *Pancakev3pairSession) Flash(recipient common.Address, amount0 *big.Int, amount1 *big.Int, data []byte) (*types.Transaction, error) { 998 return _Pancakev3pair.Contract.Flash(&_Pancakev3pair.TransactOpts, recipient, amount0, amount1, data) 999 } 1000 1001 // Flash is a paid mutator transaction binding the contract method 0x490e6cbc. 1002 // 1003 // Solidity: function flash(address recipient, uint256 amount0, uint256 amount1, bytes data) returns() 1004 func (_Pancakev3pair *Pancakev3pairTransactorSession) Flash(recipient common.Address, amount0 *big.Int, amount1 *big.Int, data []byte) (*types.Transaction, error) { 1005 return _Pancakev3pair.Contract.Flash(&_Pancakev3pair.TransactOpts, recipient, amount0, amount1, data) 1006 } 1007 1008 // IncreaseObservationCardinalityNext is a paid mutator transaction binding the contract method 0x32148f67. 1009 // 1010 // Solidity: function increaseObservationCardinalityNext(uint16 observationCardinalityNext) returns() 1011 func (_Pancakev3pair *Pancakev3pairTransactor) IncreaseObservationCardinalityNext(opts *bind.TransactOpts, observationCardinalityNext uint16) (*types.Transaction, error) { 1012 return _Pancakev3pair.contract.Transact(opts, "increaseObservationCardinalityNext", observationCardinalityNext) 1013 } 1014 1015 // IncreaseObservationCardinalityNext is a paid mutator transaction binding the contract method 0x32148f67. 1016 // 1017 // Solidity: function increaseObservationCardinalityNext(uint16 observationCardinalityNext) returns() 1018 func (_Pancakev3pair *Pancakev3pairSession) IncreaseObservationCardinalityNext(observationCardinalityNext uint16) (*types.Transaction, error) { 1019 return _Pancakev3pair.Contract.IncreaseObservationCardinalityNext(&_Pancakev3pair.TransactOpts, observationCardinalityNext) 1020 } 1021 1022 // IncreaseObservationCardinalityNext is a paid mutator transaction binding the contract method 0x32148f67. 1023 // 1024 // Solidity: function increaseObservationCardinalityNext(uint16 observationCardinalityNext) returns() 1025 func (_Pancakev3pair *Pancakev3pairTransactorSession) IncreaseObservationCardinalityNext(observationCardinalityNext uint16) (*types.Transaction, error) { 1026 return _Pancakev3pair.Contract.IncreaseObservationCardinalityNext(&_Pancakev3pair.TransactOpts, observationCardinalityNext) 1027 } 1028 1029 // Initialize is a paid mutator transaction binding the contract method 0xf637731d. 1030 // 1031 // Solidity: function initialize(uint160 sqrtPriceX96) returns() 1032 func (_Pancakev3pair *Pancakev3pairTransactor) Initialize(opts *bind.TransactOpts, sqrtPriceX96 *big.Int) (*types.Transaction, error) { 1033 return _Pancakev3pair.contract.Transact(opts, "initialize", sqrtPriceX96) 1034 } 1035 1036 // Initialize is a paid mutator transaction binding the contract method 0xf637731d. 1037 // 1038 // Solidity: function initialize(uint160 sqrtPriceX96) returns() 1039 func (_Pancakev3pair *Pancakev3pairSession) Initialize(sqrtPriceX96 *big.Int) (*types.Transaction, error) { 1040 return _Pancakev3pair.Contract.Initialize(&_Pancakev3pair.TransactOpts, sqrtPriceX96) 1041 } 1042 1043 // Initialize is a paid mutator transaction binding the contract method 0xf637731d. 1044 // 1045 // Solidity: function initialize(uint160 sqrtPriceX96) returns() 1046 func (_Pancakev3pair *Pancakev3pairTransactorSession) Initialize(sqrtPriceX96 *big.Int) (*types.Transaction, error) { 1047 return _Pancakev3pair.Contract.Initialize(&_Pancakev3pair.TransactOpts, sqrtPriceX96) 1048 } 1049 1050 // Mint is a paid mutator transaction binding the contract method 0x3c8a7d8d. 1051 // 1052 // Solidity: function mint(address recipient, int24 tickLower, int24 tickUpper, uint128 amount, bytes data) returns(uint256 amount0, uint256 amount1) 1053 func (_Pancakev3pair *Pancakev3pairTransactor) Mint(opts *bind.TransactOpts, recipient common.Address, tickLower *big.Int, tickUpper *big.Int, amount *big.Int, data []byte) (*types.Transaction, error) { 1054 return _Pancakev3pair.contract.Transact(opts, "mint", recipient, tickLower, tickUpper, amount, data) 1055 } 1056 1057 // Mint is a paid mutator transaction binding the contract method 0x3c8a7d8d. 1058 // 1059 // Solidity: function mint(address recipient, int24 tickLower, int24 tickUpper, uint128 amount, bytes data) returns(uint256 amount0, uint256 amount1) 1060 func (_Pancakev3pair *Pancakev3pairSession) Mint(recipient common.Address, tickLower *big.Int, tickUpper *big.Int, amount *big.Int, data []byte) (*types.Transaction, error) { 1061 return _Pancakev3pair.Contract.Mint(&_Pancakev3pair.TransactOpts, recipient, tickLower, tickUpper, amount, data) 1062 } 1063 1064 // Mint is a paid mutator transaction binding the contract method 0x3c8a7d8d. 1065 // 1066 // Solidity: function mint(address recipient, int24 tickLower, int24 tickUpper, uint128 amount, bytes data) returns(uint256 amount0, uint256 amount1) 1067 func (_Pancakev3pair *Pancakev3pairTransactorSession) Mint(recipient common.Address, tickLower *big.Int, tickUpper *big.Int, amount *big.Int, data []byte) (*types.Transaction, error) { 1068 return _Pancakev3pair.Contract.Mint(&_Pancakev3pair.TransactOpts, recipient, tickLower, tickUpper, amount, data) 1069 } 1070 1071 // SetFeeProtocol is a paid mutator transaction binding the contract method 0xb0d0d211. 1072 // 1073 // Solidity: function setFeeProtocol(uint32 feeProtocol0, uint32 feeProtocol1) returns() 1074 func (_Pancakev3pair *Pancakev3pairTransactor) SetFeeProtocol(opts *bind.TransactOpts, feeProtocol0 uint32, feeProtocol1 uint32) (*types.Transaction, error) { 1075 return _Pancakev3pair.contract.Transact(opts, "setFeeProtocol", feeProtocol0, feeProtocol1) 1076 } 1077 1078 // SetFeeProtocol is a paid mutator transaction binding the contract method 0xb0d0d211. 1079 // 1080 // Solidity: function setFeeProtocol(uint32 feeProtocol0, uint32 feeProtocol1) returns() 1081 func (_Pancakev3pair *Pancakev3pairSession) SetFeeProtocol(feeProtocol0 uint32, feeProtocol1 uint32) (*types.Transaction, error) { 1082 return _Pancakev3pair.Contract.SetFeeProtocol(&_Pancakev3pair.TransactOpts, feeProtocol0, feeProtocol1) 1083 } 1084 1085 // SetFeeProtocol is a paid mutator transaction binding the contract method 0xb0d0d211. 1086 // 1087 // Solidity: function setFeeProtocol(uint32 feeProtocol0, uint32 feeProtocol1) returns() 1088 func (_Pancakev3pair *Pancakev3pairTransactorSession) SetFeeProtocol(feeProtocol0 uint32, feeProtocol1 uint32) (*types.Transaction, error) { 1089 return _Pancakev3pair.Contract.SetFeeProtocol(&_Pancakev3pair.TransactOpts, feeProtocol0, feeProtocol1) 1090 } 1091 1092 // SetLmPool is a paid mutator transaction binding the contract method 0xcc7e7fa2. 1093 // 1094 // Solidity: function setLmPool(address _lmPool) returns() 1095 func (_Pancakev3pair *Pancakev3pairTransactor) SetLmPool(opts *bind.TransactOpts, _lmPool common.Address) (*types.Transaction, error) { 1096 return _Pancakev3pair.contract.Transact(opts, "setLmPool", _lmPool) 1097 } 1098 1099 // SetLmPool is a paid mutator transaction binding the contract method 0xcc7e7fa2. 1100 // 1101 // Solidity: function setLmPool(address _lmPool) returns() 1102 func (_Pancakev3pair *Pancakev3pairSession) SetLmPool(_lmPool common.Address) (*types.Transaction, error) { 1103 return _Pancakev3pair.Contract.SetLmPool(&_Pancakev3pair.TransactOpts, _lmPool) 1104 } 1105 1106 // SetLmPool is a paid mutator transaction binding the contract method 0xcc7e7fa2. 1107 // 1108 // Solidity: function setLmPool(address _lmPool) returns() 1109 func (_Pancakev3pair *Pancakev3pairTransactorSession) SetLmPool(_lmPool common.Address) (*types.Transaction, error) { 1110 return _Pancakev3pair.Contract.SetLmPool(&_Pancakev3pair.TransactOpts, _lmPool) 1111 } 1112 1113 // Swap is a paid mutator transaction binding the contract method 0x128acb08. 1114 // 1115 // Solidity: function swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes data) returns(int256 amount0, int256 amount1) 1116 func (_Pancakev3pair *Pancakev3pairTransactor) Swap(opts *bind.TransactOpts, recipient common.Address, zeroForOne bool, amountSpecified *big.Int, sqrtPriceLimitX96 *big.Int, data []byte) (*types.Transaction, error) { 1117 return _Pancakev3pair.contract.Transact(opts, "swap", recipient, zeroForOne, amountSpecified, sqrtPriceLimitX96, data) 1118 } 1119 1120 // Swap is a paid mutator transaction binding the contract method 0x128acb08. 1121 // 1122 // Solidity: function swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes data) returns(int256 amount0, int256 amount1) 1123 func (_Pancakev3pair *Pancakev3pairSession) Swap(recipient common.Address, zeroForOne bool, amountSpecified *big.Int, sqrtPriceLimitX96 *big.Int, data []byte) (*types.Transaction, error) { 1124 return _Pancakev3pair.Contract.Swap(&_Pancakev3pair.TransactOpts, recipient, zeroForOne, amountSpecified, sqrtPriceLimitX96, data) 1125 } 1126 1127 // Swap is a paid mutator transaction binding the contract method 0x128acb08. 1128 // 1129 // Solidity: function swap(address recipient, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, bytes data) returns(int256 amount0, int256 amount1) 1130 func (_Pancakev3pair *Pancakev3pairTransactorSession) Swap(recipient common.Address, zeroForOne bool, amountSpecified *big.Int, sqrtPriceLimitX96 *big.Int, data []byte) (*types.Transaction, error) { 1131 return _Pancakev3pair.Contract.Swap(&_Pancakev3pair.TransactOpts, recipient, zeroForOne, amountSpecified, sqrtPriceLimitX96, data) 1132 } 1133 1134 // Pancakev3pairBurnIterator is returned from FilterBurn and is used to iterate over the raw logs and unpacked data for Burn events raised by the Pancakev3pair contract. 1135 type Pancakev3pairBurnIterator struct { 1136 Event *Pancakev3pairBurn // Event containing the contract specifics and raw log 1137 1138 contract *bind.BoundContract // Generic contract to use for unpacking event data 1139 event string // Event name to use for unpacking event data 1140 1141 logs chan types.Log // Log channel receiving the found contract events 1142 sub ethereum.Subscription // Subscription for errors, completion and termination 1143 done bool // Whether the subscription completed delivering logs 1144 fail error // Occurred error to stop iteration 1145 } 1146 1147 // Next advances the iterator to the subsequent event, returning whether there 1148 // are any more events found. In case of a retrieval or parsing error, false is 1149 // returned and Error() can be queried for the exact failure. 1150 func (it *Pancakev3pairBurnIterator) Next() bool { 1151 // If the iterator failed, stop iterating 1152 if it.fail != nil { 1153 return false 1154 } 1155 // If the iterator completed, deliver directly whatever's available 1156 if it.done { 1157 select { 1158 case log := <-it.logs: 1159 it.Event = new(Pancakev3pairBurn) 1160 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1161 it.fail = err 1162 return false 1163 } 1164 it.Event.Raw = log 1165 return true 1166 1167 default: 1168 return false 1169 } 1170 } 1171 // Iterator still in progress, wait for either a data or an error event 1172 select { 1173 case log := <-it.logs: 1174 it.Event = new(Pancakev3pairBurn) 1175 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1176 it.fail = err 1177 return false 1178 } 1179 it.Event.Raw = log 1180 return true 1181 1182 case err := <-it.sub.Err(): 1183 it.done = true 1184 it.fail = err 1185 return it.Next() 1186 } 1187 } 1188 1189 // Error returns any retrieval or parsing error occurred during filtering. 1190 func (it *Pancakev3pairBurnIterator) Error() error { 1191 return it.fail 1192 } 1193 1194 // Close terminates the iteration process, releasing any pending underlying 1195 // resources. 1196 func (it *Pancakev3pairBurnIterator) Close() error { 1197 it.sub.Unsubscribe() 1198 return nil 1199 } 1200 1201 // Pancakev3pairBurn represents a Burn event raised by the Pancakev3pair contract. 1202 type Pancakev3pairBurn struct { 1203 Owner common.Address 1204 TickLower *big.Int 1205 TickUpper *big.Int 1206 Amount *big.Int 1207 Amount0 *big.Int 1208 Amount1 *big.Int 1209 Raw types.Log // Blockchain specific contextual infos 1210 } 1211 1212 // FilterBurn is a free log retrieval operation binding the contract event 0x0c396cd989a39f4459b5fa1aed6a9a8dcdbc45908acfd67e028cd568da98982c. 1213 // 1214 // Solidity: event Burn(address indexed owner, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount, uint256 amount0, uint256 amount1) 1215 func (_Pancakev3pair *Pancakev3pairFilterer) FilterBurn(opts *bind.FilterOpts, owner []common.Address, tickLower []*big.Int, tickUpper []*big.Int) (*Pancakev3pairBurnIterator, error) { 1216 1217 var ownerRule []interface{} 1218 for _, ownerItem := range owner { 1219 ownerRule = append(ownerRule, ownerItem) 1220 } 1221 var tickLowerRule []interface{} 1222 for _, tickLowerItem := range tickLower { 1223 tickLowerRule = append(tickLowerRule, tickLowerItem) 1224 } 1225 var tickUpperRule []interface{} 1226 for _, tickUpperItem := range tickUpper { 1227 tickUpperRule = append(tickUpperRule, tickUpperItem) 1228 } 1229 1230 logs, sub, err := _Pancakev3pair.contract.FilterLogs(opts, "Burn", ownerRule, tickLowerRule, tickUpperRule) 1231 if err != nil { 1232 return nil, err 1233 } 1234 return &Pancakev3pairBurnIterator{contract: _Pancakev3pair.contract, event: "Burn", logs: logs, sub: sub}, nil 1235 } 1236 1237 // WatchBurn is a free log subscription operation binding the contract event 0x0c396cd989a39f4459b5fa1aed6a9a8dcdbc45908acfd67e028cd568da98982c. 1238 // 1239 // Solidity: event Burn(address indexed owner, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount, uint256 amount0, uint256 amount1) 1240 func (_Pancakev3pair *Pancakev3pairFilterer) WatchBurn(opts *bind.WatchOpts, sink chan<- *Pancakev3pairBurn, owner []common.Address, tickLower []*big.Int, tickUpper []*big.Int) (event.Subscription, error) { 1241 1242 var ownerRule []interface{} 1243 for _, ownerItem := range owner { 1244 ownerRule = append(ownerRule, ownerItem) 1245 } 1246 var tickLowerRule []interface{} 1247 for _, tickLowerItem := range tickLower { 1248 tickLowerRule = append(tickLowerRule, tickLowerItem) 1249 } 1250 var tickUpperRule []interface{} 1251 for _, tickUpperItem := range tickUpper { 1252 tickUpperRule = append(tickUpperRule, tickUpperItem) 1253 } 1254 1255 logs, sub, err := _Pancakev3pair.contract.WatchLogs(opts, "Burn", ownerRule, tickLowerRule, tickUpperRule) 1256 if err != nil { 1257 return nil, err 1258 } 1259 return event.NewSubscription(func(quit <-chan struct{}) error { 1260 defer sub.Unsubscribe() 1261 for { 1262 select { 1263 case log := <-logs: 1264 // New log arrived, parse the event and forward to the user 1265 event := new(Pancakev3pairBurn) 1266 if err := _Pancakev3pair.contract.UnpackLog(event, "Burn", log); err != nil { 1267 return err 1268 } 1269 event.Raw = log 1270 1271 select { 1272 case sink <- event: 1273 case err := <-sub.Err(): 1274 return err 1275 case <-quit: 1276 return nil 1277 } 1278 case err := <-sub.Err(): 1279 return err 1280 case <-quit: 1281 return nil 1282 } 1283 } 1284 }), nil 1285 } 1286 1287 // ParseBurn is a log parse operation binding the contract event 0x0c396cd989a39f4459b5fa1aed6a9a8dcdbc45908acfd67e028cd568da98982c. 1288 // 1289 // Solidity: event Burn(address indexed owner, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount, uint256 amount0, uint256 amount1) 1290 func (_Pancakev3pair *Pancakev3pairFilterer) ParseBurn(log types.Log) (*Pancakev3pairBurn, error) { 1291 event := new(Pancakev3pairBurn) 1292 if err := _Pancakev3pair.contract.UnpackLog(event, "Burn", log); err != nil { 1293 return nil, err 1294 } 1295 event.Raw = log 1296 return event, nil 1297 } 1298 1299 // Pancakev3pairCollectIterator is returned from FilterCollect and is used to iterate over the raw logs and unpacked data for Collect events raised by the Pancakev3pair contract. 1300 type Pancakev3pairCollectIterator struct { 1301 Event *Pancakev3pairCollect // Event containing the contract specifics and raw log 1302 1303 contract *bind.BoundContract // Generic contract to use for unpacking event data 1304 event string // Event name to use for unpacking event data 1305 1306 logs chan types.Log // Log channel receiving the found contract events 1307 sub ethereum.Subscription // Subscription for errors, completion and termination 1308 done bool // Whether the subscription completed delivering logs 1309 fail error // Occurred error to stop iteration 1310 } 1311 1312 // Next advances the iterator to the subsequent event, returning whether there 1313 // are any more events found. In case of a retrieval or parsing error, false is 1314 // returned and Error() can be queried for the exact failure. 1315 func (it *Pancakev3pairCollectIterator) Next() bool { 1316 // If the iterator failed, stop iterating 1317 if it.fail != nil { 1318 return false 1319 } 1320 // If the iterator completed, deliver directly whatever's available 1321 if it.done { 1322 select { 1323 case log := <-it.logs: 1324 it.Event = new(Pancakev3pairCollect) 1325 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1326 it.fail = err 1327 return false 1328 } 1329 it.Event.Raw = log 1330 return true 1331 1332 default: 1333 return false 1334 } 1335 } 1336 // Iterator still in progress, wait for either a data or an error event 1337 select { 1338 case log := <-it.logs: 1339 it.Event = new(Pancakev3pairCollect) 1340 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1341 it.fail = err 1342 return false 1343 } 1344 it.Event.Raw = log 1345 return true 1346 1347 case err := <-it.sub.Err(): 1348 it.done = true 1349 it.fail = err 1350 return it.Next() 1351 } 1352 } 1353 1354 // Error returns any retrieval or parsing error occurred during filtering. 1355 func (it *Pancakev3pairCollectIterator) Error() error { 1356 return it.fail 1357 } 1358 1359 // Close terminates the iteration process, releasing any pending underlying 1360 // resources. 1361 func (it *Pancakev3pairCollectIterator) Close() error { 1362 it.sub.Unsubscribe() 1363 return nil 1364 } 1365 1366 // Pancakev3pairCollect represents a Collect event raised by the Pancakev3pair contract. 1367 type Pancakev3pairCollect struct { 1368 Owner common.Address 1369 Recipient common.Address 1370 TickLower *big.Int 1371 TickUpper *big.Int 1372 Amount0 *big.Int 1373 Amount1 *big.Int 1374 Raw types.Log // Blockchain specific contextual infos 1375 } 1376 1377 // FilterCollect is a free log retrieval operation binding the contract event 0x70935338e69775456a85ddef226c395fb668b63fa0115f5f20610b388e6ca9c0. 1378 // 1379 // Solidity: event Collect(address indexed owner, address recipient, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount0, uint128 amount1) 1380 func (_Pancakev3pair *Pancakev3pairFilterer) FilterCollect(opts *bind.FilterOpts, owner []common.Address, tickLower []*big.Int, tickUpper []*big.Int) (*Pancakev3pairCollectIterator, error) { 1381 1382 var ownerRule []interface{} 1383 for _, ownerItem := range owner { 1384 ownerRule = append(ownerRule, ownerItem) 1385 } 1386 1387 var tickLowerRule []interface{} 1388 for _, tickLowerItem := range tickLower { 1389 tickLowerRule = append(tickLowerRule, tickLowerItem) 1390 } 1391 var tickUpperRule []interface{} 1392 for _, tickUpperItem := range tickUpper { 1393 tickUpperRule = append(tickUpperRule, tickUpperItem) 1394 } 1395 1396 logs, sub, err := _Pancakev3pair.contract.FilterLogs(opts, "Collect", ownerRule, tickLowerRule, tickUpperRule) 1397 if err != nil { 1398 return nil, err 1399 } 1400 return &Pancakev3pairCollectIterator{contract: _Pancakev3pair.contract, event: "Collect", logs: logs, sub: sub}, nil 1401 } 1402 1403 // WatchCollect is a free log subscription operation binding the contract event 0x70935338e69775456a85ddef226c395fb668b63fa0115f5f20610b388e6ca9c0. 1404 // 1405 // Solidity: event Collect(address indexed owner, address recipient, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount0, uint128 amount1) 1406 func (_Pancakev3pair *Pancakev3pairFilterer) WatchCollect(opts *bind.WatchOpts, sink chan<- *Pancakev3pairCollect, owner []common.Address, tickLower []*big.Int, tickUpper []*big.Int) (event.Subscription, error) { 1407 1408 var ownerRule []interface{} 1409 for _, ownerItem := range owner { 1410 ownerRule = append(ownerRule, ownerItem) 1411 } 1412 1413 var tickLowerRule []interface{} 1414 for _, tickLowerItem := range tickLower { 1415 tickLowerRule = append(tickLowerRule, tickLowerItem) 1416 } 1417 var tickUpperRule []interface{} 1418 for _, tickUpperItem := range tickUpper { 1419 tickUpperRule = append(tickUpperRule, tickUpperItem) 1420 } 1421 1422 logs, sub, err := _Pancakev3pair.contract.WatchLogs(opts, "Collect", ownerRule, tickLowerRule, tickUpperRule) 1423 if err != nil { 1424 return nil, err 1425 } 1426 return event.NewSubscription(func(quit <-chan struct{}) error { 1427 defer sub.Unsubscribe() 1428 for { 1429 select { 1430 case log := <-logs: 1431 // New log arrived, parse the event and forward to the user 1432 event := new(Pancakev3pairCollect) 1433 if err := _Pancakev3pair.contract.UnpackLog(event, "Collect", log); err != nil { 1434 return err 1435 } 1436 event.Raw = log 1437 1438 select { 1439 case sink <- event: 1440 case err := <-sub.Err(): 1441 return err 1442 case <-quit: 1443 return nil 1444 } 1445 case err := <-sub.Err(): 1446 return err 1447 case <-quit: 1448 return nil 1449 } 1450 } 1451 }), nil 1452 } 1453 1454 // ParseCollect is a log parse operation binding the contract event 0x70935338e69775456a85ddef226c395fb668b63fa0115f5f20610b388e6ca9c0. 1455 // 1456 // Solidity: event Collect(address indexed owner, address recipient, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount0, uint128 amount1) 1457 func (_Pancakev3pair *Pancakev3pairFilterer) ParseCollect(log types.Log) (*Pancakev3pairCollect, error) { 1458 event := new(Pancakev3pairCollect) 1459 if err := _Pancakev3pair.contract.UnpackLog(event, "Collect", log); err != nil { 1460 return nil, err 1461 } 1462 event.Raw = log 1463 return event, nil 1464 } 1465 1466 // Pancakev3pairCollectProtocolIterator is returned from FilterCollectProtocol and is used to iterate over the raw logs and unpacked data for CollectProtocol events raised by the Pancakev3pair contract. 1467 type Pancakev3pairCollectProtocolIterator struct { 1468 Event *Pancakev3pairCollectProtocol // Event containing the contract specifics and raw log 1469 1470 contract *bind.BoundContract // Generic contract to use for unpacking event data 1471 event string // Event name to use for unpacking event data 1472 1473 logs chan types.Log // Log channel receiving the found contract events 1474 sub ethereum.Subscription // Subscription for errors, completion and termination 1475 done bool // Whether the subscription completed delivering logs 1476 fail error // Occurred error to stop iteration 1477 } 1478 1479 // Next advances the iterator to the subsequent event, returning whether there 1480 // are any more events found. In case of a retrieval or parsing error, false is 1481 // returned and Error() can be queried for the exact failure. 1482 func (it *Pancakev3pairCollectProtocolIterator) Next() bool { 1483 // If the iterator failed, stop iterating 1484 if it.fail != nil { 1485 return false 1486 } 1487 // If the iterator completed, deliver directly whatever's available 1488 if it.done { 1489 select { 1490 case log := <-it.logs: 1491 it.Event = new(Pancakev3pairCollectProtocol) 1492 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1493 it.fail = err 1494 return false 1495 } 1496 it.Event.Raw = log 1497 return true 1498 1499 default: 1500 return false 1501 } 1502 } 1503 // Iterator still in progress, wait for either a data or an error event 1504 select { 1505 case log := <-it.logs: 1506 it.Event = new(Pancakev3pairCollectProtocol) 1507 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1508 it.fail = err 1509 return false 1510 } 1511 it.Event.Raw = log 1512 return true 1513 1514 case err := <-it.sub.Err(): 1515 it.done = true 1516 it.fail = err 1517 return it.Next() 1518 } 1519 } 1520 1521 // Error returns any retrieval or parsing error occurred during filtering. 1522 func (it *Pancakev3pairCollectProtocolIterator) Error() error { 1523 return it.fail 1524 } 1525 1526 // Close terminates the iteration process, releasing any pending underlying 1527 // resources. 1528 func (it *Pancakev3pairCollectProtocolIterator) Close() error { 1529 it.sub.Unsubscribe() 1530 return nil 1531 } 1532 1533 // Pancakev3pairCollectProtocol represents a CollectProtocol event raised by the Pancakev3pair contract. 1534 type Pancakev3pairCollectProtocol struct { 1535 Sender common.Address 1536 Recipient common.Address 1537 Amount0 *big.Int 1538 Amount1 *big.Int 1539 Raw types.Log // Blockchain specific contextual infos 1540 } 1541 1542 // FilterCollectProtocol is a free log retrieval operation binding the contract event 0x596b573906218d3411850b26a6b437d6c4522fdb43d2d2386263f86d50b8b151. 1543 // 1544 // Solidity: event CollectProtocol(address indexed sender, address indexed recipient, uint128 amount0, uint128 amount1) 1545 func (_Pancakev3pair *Pancakev3pairFilterer) FilterCollectProtocol(opts *bind.FilterOpts, sender []common.Address, recipient []common.Address) (*Pancakev3pairCollectProtocolIterator, error) { 1546 1547 var senderRule []interface{} 1548 for _, senderItem := range sender { 1549 senderRule = append(senderRule, senderItem) 1550 } 1551 var recipientRule []interface{} 1552 for _, recipientItem := range recipient { 1553 recipientRule = append(recipientRule, recipientItem) 1554 } 1555 1556 logs, sub, err := _Pancakev3pair.contract.FilterLogs(opts, "CollectProtocol", senderRule, recipientRule) 1557 if err != nil { 1558 return nil, err 1559 } 1560 return &Pancakev3pairCollectProtocolIterator{contract: _Pancakev3pair.contract, event: "CollectProtocol", logs: logs, sub: sub}, nil 1561 } 1562 1563 // WatchCollectProtocol is a free log subscription operation binding the contract event 0x596b573906218d3411850b26a6b437d6c4522fdb43d2d2386263f86d50b8b151. 1564 // 1565 // Solidity: event CollectProtocol(address indexed sender, address indexed recipient, uint128 amount0, uint128 amount1) 1566 func (_Pancakev3pair *Pancakev3pairFilterer) WatchCollectProtocol(opts *bind.WatchOpts, sink chan<- *Pancakev3pairCollectProtocol, sender []common.Address, recipient []common.Address) (event.Subscription, error) { 1567 1568 var senderRule []interface{} 1569 for _, senderItem := range sender { 1570 senderRule = append(senderRule, senderItem) 1571 } 1572 var recipientRule []interface{} 1573 for _, recipientItem := range recipient { 1574 recipientRule = append(recipientRule, recipientItem) 1575 } 1576 1577 logs, sub, err := _Pancakev3pair.contract.WatchLogs(opts, "CollectProtocol", senderRule, recipientRule) 1578 if err != nil { 1579 return nil, err 1580 } 1581 return event.NewSubscription(func(quit <-chan struct{}) error { 1582 defer sub.Unsubscribe() 1583 for { 1584 select { 1585 case log := <-logs: 1586 // New log arrived, parse the event and forward to the user 1587 event := new(Pancakev3pairCollectProtocol) 1588 if err := _Pancakev3pair.contract.UnpackLog(event, "CollectProtocol", log); err != nil { 1589 return err 1590 } 1591 event.Raw = log 1592 1593 select { 1594 case sink <- event: 1595 case err := <-sub.Err(): 1596 return err 1597 case <-quit: 1598 return nil 1599 } 1600 case err := <-sub.Err(): 1601 return err 1602 case <-quit: 1603 return nil 1604 } 1605 } 1606 }), nil 1607 } 1608 1609 // ParseCollectProtocol is a log parse operation binding the contract event 0x596b573906218d3411850b26a6b437d6c4522fdb43d2d2386263f86d50b8b151. 1610 // 1611 // Solidity: event CollectProtocol(address indexed sender, address indexed recipient, uint128 amount0, uint128 amount1) 1612 func (_Pancakev3pair *Pancakev3pairFilterer) ParseCollectProtocol(log types.Log) (*Pancakev3pairCollectProtocol, error) { 1613 event := new(Pancakev3pairCollectProtocol) 1614 if err := _Pancakev3pair.contract.UnpackLog(event, "CollectProtocol", log); err != nil { 1615 return nil, err 1616 } 1617 event.Raw = log 1618 return event, nil 1619 } 1620 1621 // Pancakev3pairFlashIterator is returned from FilterFlash and is used to iterate over the raw logs and unpacked data for Flash events raised by the Pancakev3pair contract. 1622 type Pancakev3pairFlashIterator struct { 1623 Event *Pancakev3pairFlash // Event containing the contract specifics and raw log 1624 1625 contract *bind.BoundContract // Generic contract to use for unpacking event data 1626 event string // Event name to use for unpacking event data 1627 1628 logs chan types.Log // Log channel receiving the found contract events 1629 sub ethereum.Subscription // Subscription for errors, completion and termination 1630 done bool // Whether the subscription completed delivering logs 1631 fail error // Occurred error to stop iteration 1632 } 1633 1634 // Next advances the iterator to the subsequent event, returning whether there 1635 // are any more events found. In case of a retrieval or parsing error, false is 1636 // returned and Error() can be queried for the exact failure. 1637 func (it *Pancakev3pairFlashIterator) Next() bool { 1638 // If the iterator failed, stop iterating 1639 if it.fail != nil { 1640 return false 1641 } 1642 // If the iterator completed, deliver directly whatever's available 1643 if it.done { 1644 select { 1645 case log := <-it.logs: 1646 it.Event = new(Pancakev3pairFlash) 1647 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1648 it.fail = err 1649 return false 1650 } 1651 it.Event.Raw = log 1652 return true 1653 1654 default: 1655 return false 1656 } 1657 } 1658 // Iterator still in progress, wait for either a data or an error event 1659 select { 1660 case log := <-it.logs: 1661 it.Event = new(Pancakev3pairFlash) 1662 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1663 it.fail = err 1664 return false 1665 } 1666 it.Event.Raw = log 1667 return true 1668 1669 case err := <-it.sub.Err(): 1670 it.done = true 1671 it.fail = err 1672 return it.Next() 1673 } 1674 } 1675 1676 // Error returns any retrieval or parsing error occurred during filtering. 1677 func (it *Pancakev3pairFlashIterator) Error() error { 1678 return it.fail 1679 } 1680 1681 // Close terminates the iteration process, releasing any pending underlying 1682 // resources. 1683 func (it *Pancakev3pairFlashIterator) Close() error { 1684 it.sub.Unsubscribe() 1685 return nil 1686 } 1687 1688 // Pancakev3pairFlash represents a Flash event raised by the Pancakev3pair contract. 1689 type Pancakev3pairFlash struct { 1690 Sender common.Address 1691 Recipient common.Address 1692 Amount0 *big.Int 1693 Amount1 *big.Int 1694 Paid0 *big.Int 1695 Paid1 *big.Int 1696 Raw types.Log // Blockchain specific contextual infos 1697 } 1698 1699 // FilterFlash is a free log retrieval operation binding the contract event 0xbdbdb71d7860376ba52b25a5028beea23581364a40522f6bcfb86bb1f2dca633. 1700 // 1701 // Solidity: event Flash(address indexed sender, address indexed recipient, uint256 amount0, uint256 amount1, uint256 paid0, uint256 paid1) 1702 func (_Pancakev3pair *Pancakev3pairFilterer) FilterFlash(opts *bind.FilterOpts, sender []common.Address, recipient []common.Address) (*Pancakev3pairFlashIterator, error) { 1703 1704 var senderRule []interface{} 1705 for _, senderItem := range sender { 1706 senderRule = append(senderRule, senderItem) 1707 } 1708 var recipientRule []interface{} 1709 for _, recipientItem := range recipient { 1710 recipientRule = append(recipientRule, recipientItem) 1711 } 1712 1713 logs, sub, err := _Pancakev3pair.contract.FilterLogs(opts, "Flash", senderRule, recipientRule) 1714 if err != nil { 1715 return nil, err 1716 } 1717 return &Pancakev3pairFlashIterator{contract: _Pancakev3pair.contract, event: "Flash", logs: logs, sub: sub}, nil 1718 } 1719 1720 // WatchFlash is a free log subscription operation binding the contract event 0xbdbdb71d7860376ba52b25a5028beea23581364a40522f6bcfb86bb1f2dca633. 1721 // 1722 // Solidity: event Flash(address indexed sender, address indexed recipient, uint256 amount0, uint256 amount1, uint256 paid0, uint256 paid1) 1723 func (_Pancakev3pair *Pancakev3pairFilterer) WatchFlash(opts *bind.WatchOpts, sink chan<- *Pancakev3pairFlash, sender []common.Address, recipient []common.Address) (event.Subscription, error) { 1724 1725 var senderRule []interface{} 1726 for _, senderItem := range sender { 1727 senderRule = append(senderRule, senderItem) 1728 } 1729 var recipientRule []interface{} 1730 for _, recipientItem := range recipient { 1731 recipientRule = append(recipientRule, recipientItem) 1732 } 1733 1734 logs, sub, err := _Pancakev3pair.contract.WatchLogs(opts, "Flash", senderRule, recipientRule) 1735 if err != nil { 1736 return nil, err 1737 } 1738 return event.NewSubscription(func(quit <-chan struct{}) error { 1739 defer sub.Unsubscribe() 1740 for { 1741 select { 1742 case log := <-logs: 1743 // New log arrived, parse the event and forward to the user 1744 event := new(Pancakev3pairFlash) 1745 if err := _Pancakev3pair.contract.UnpackLog(event, "Flash", log); err != nil { 1746 return err 1747 } 1748 event.Raw = log 1749 1750 select { 1751 case sink <- event: 1752 case err := <-sub.Err(): 1753 return err 1754 case <-quit: 1755 return nil 1756 } 1757 case err := <-sub.Err(): 1758 return err 1759 case <-quit: 1760 return nil 1761 } 1762 } 1763 }), nil 1764 } 1765 1766 // ParseFlash is a log parse operation binding the contract event 0xbdbdb71d7860376ba52b25a5028beea23581364a40522f6bcfb86bb1f2dca633. 1767 // 1768 // Solidity: event Flash(address indexed sender, address indexed recipient, uint256 amount0, uint256 amount1, uint256 paid0, uint256 paid1) 1769 func (_Pancakev3pair *Pancakev3pairFilterer) ParseFlash(log types.Log) (*Pancakev3pairFlash, error) { 1770 event := new(Pancakev3pairFlash) 1771 if err := _Pancakev3pair.contract.UnpackLog(event, "Flash", log); err != nil { 1772 return nil, err 1773 } 1774 event.Raw = log 1775 return event, nil 1776 } 1777 1778 // Pancakev3pairIncreaseObservationCardinalityNextIterator is returned from FilterIncreaseObservationCardinalityNext and is used to iterate over the raw logs and unpacked data for IncreaseObservationCardinalityNext events raised by the Pancakev3pair contract. 1779 type Pancakev3pairIncreaseObservationCardinalityNextIterator struct { 1780 Event *Pancakev3pairIncreaseObservationCardinalityNext // Event containing the contract specifics and raw log 1781 1782 contract *bind.BoundContract // Generic contract to use for unpacking event data 1783 event string // Event name to use for unpacking event data 1784 1785 logs chan types.Log // Log channel receiving the found contract events 1786 sub ethereum.Subscription // Subscription for errors, completion and termination 1787 done bool // Whether the subscription completed delivering logs 1788 fail error // Occurred error to stop iteration 1789 } 1790 1791 // Next advances the iterator to the subsequent event, returning whether there 1792 // are any more events found. In case of a retrieval or parsing error, false is 1793 // returned and Error() can be queried for the exact failure. 1794 func (it *Pancakev3pairIncreaseObservationCardinalityNextIterator) Next() bool { 1795 // If the iterator failed, stop iterating 1796 if it.fail != nil { 1797 return false 1798 } 1799 // If the iterator completed, deliver directly whatever's available 1800 if it.done { 1801 select { 1802 case log := <-it.logs: 1803 it.Event = new(Pancakev3pairIncreaseObservationCardinalityNext) 1804 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1805 it.fail = err 1806 return false 1807 } 1808 it.Event.Raw = log 1809 return true 1810 1811 default: 1812 return false 1813 } 1814 } 1815 // Iterator still in progress, wait for either a data or an error event 1816 select { 1817 case log := <-it.logs: 1818 it.Event = new(Pancakev3pairIncreaseObservationCardinalityNext) 1819 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1820 it.fail = err 1821 return false 1822 } 1823 it.Event.Raw = log 1824 return true 1825 1826 case err := <-it.sub.Err(): 1827 it.done = true 1828 it.fail = err 1829 return it.Next() 1830 } 1831 } 1832 1833 // Error returns any retrieval or parsing error occurred during filtering. 1834 func (it *Pancakev3pairIncreaseObservationCardinalityNextIterator) Error() error { 1835 return it.fail 1836 } 1837 1838 // Close terminates the iteration process, releasing any pending underlying 1839 // resources. 1840 func (it *Pancakev3pairIncreaseObservationCardinalityNextIterator) Close() error { 1841 it.sub.Unsubscribe() 1842 return nil 1843 } 1844 1845 // Pancakev3pairIncreaseObservationCardinalityNext represents a IncreaseObservationCardinalityNext event raised by the Pancakev3pair contract. 1846 type Pancakev3pairIncreaseObservationCardinalityNext struct { 1847 ObservationCardinalityNextOld uint16 1848 ObservationCardinalityNextNew uint16 1849 Raw types.Log // Blockchain specific contextual infos 1850 } 1851 1852 // FilterIncreaseObservationCardinalityNext is a free log retrieval operation binding the contract event 0xac49e518f90a358f652e4400164f05a5d8f7e35e7747279bc3a93dbf584e125a. 1853 // 1854 // Solidity: event IncreaseObservationCardinalityNext(uint16 observationCardinalityNextOld, uint16 observationCardinalityNextNew) 1855 func (_Pancakev3pair *Pancakev3pairFilterer) FilterIncreaseObservationCardinalityNext(opts *bind.FilterOpts) (*Pancakev3pairIncreaseObservationCardinalityNextIterator, error) { 1856 1857 logs, sub, err := _Pancakev3pair.contract.FilterLogs(opts, "IncreaseObservationCardinalityNext") 1858 if err != nil { 1859 return nil, err 1860 } 1861 return &Pancakev3pairIncreaseObservationCardinalityNextIterator{contract: _Pancakev3pair.contract, event: "IncreaseObservationCardinalityNext", logs: logs, sub: sub}, nil 1862 } 1863 1864 // WatchIncreaseObservationCardinalityNext is a free log subscription operation binding the contract event 0xac49e518f90a358f652e4400164f05a5d8f7e35e7747279bc3a93dbf584e125a. 1865 // 1866 // Solidity: event IncreaseObservationCardinalityNext(uint16 observationCardinalityNextOld, uint16 observationCardinalityNextNew) 1867 func (_Pancakev3pair *Pancakev3pairFilterer) WatchIncreaseObservationCardinalityNext(opts *bind.WatchOpts, sink chan<- *Pancakev3pairIncreaseObservationCardinalityNext) (event.Subscription, error) { 1868 1869 logs, sub, err := _Pancakev3pair.contract.WatchLogs(opts, "IncreaseObservationCardinalityNext") 1870 if err != nil { 1871 return nil, err 1872 } 1873 return event.NewSubscription(func(quit <-chan struct{}) error { 1874 defer sub.Unsubscribe() 1875 for { 1876 select { 1877 case log := <-logs: 1878 // New log arrived, parse the event and forward to the user 1879 event := new(Pancakev3pairIncreaseObservationCardinalityNext) 1880 if err := _Pancakev3pair.contract.UnpackLog(event, "IncreaseObservationCardinalityNext", log); err != nil { 1881 return err 1882 } 1883 event.Raw = log 1884 1885 select { 1886 case sink <- event: 1887 case err := <-sub.Err(): 1888 return err 1889 case <-quit: 1890 return nil 1891 } 1892 case err := <-sub.Err(): 1893 return err 1894 case <-quit: 1895 return nil 1896 } 1897 } 1898 }), nil 1899 } 1900 1901 // ParseIncreaseObservationCardinalityNext is a log parse operation binding the contract event 0xac49e518f90a358f652e4400164f05a5d8f7e35e7747279bc3a93dbf584e125a. 1902 // 1903 // Solidity: event IncreaseObservationCardinalityNext(uint16 observationCardinalityNextOld, uint16 observationCardinalityNextNew) 1904 func (_Pancakev3pair *Pancakev3pairFilterer) ParseIncreaseObservationCardinalityNext(log types.Log) (*Pancakev3pairIncreaseObservationCardinalityNext, error) { 1905 event := new(Pancakev3pairIncreaseObservationCardinalityNext) 1906 if err := _Pancakev3pair.contract.UnpackLog(event, "IncreaseObservationCardinalityNext", log); err != nil { 1907 return nil, err 1908 } 1909 event.Raw = log 1910 return event, nil 1911 } 1912 1913 // Pancakev3pairInitializeIterator is returned from FilterInitialize and is used to iterate over the raw logs and unpacked data for Initialize events raised by the Pancakev3pair contract. 1914 type Pancakev3pairInitializeIterator struct { 1915 Event *Pancakev3pairInitialize // Event containing the contract specifics and raw log 1916 1917 contract *bind.BoundContract // Generic contract to use for unpacking event data 1918 event string // Event name to use for unpacking event data 1919 1920 logs chan types.Log // Log channel receiving the found contract events 1921 sub ethereum.Subscription // Subscription for errors, completion and termination 1922 done bool // Whether the subscription completed delivering logs 1923 fail error // Occurred error to stop iteration 1924 } 1925 1926 // Next advances the iterator to the subsequent event, returning whether there 1927 // are any more events found. In case of a retrieval or parsing error, false is 1928 // returned and Error() can be queried for the exact failure. 1929 func (it *Pancakev3pairInitializeIterator) Next() bool { 1930 // If the iterator failed, stop iterating 1931 if it.fail != nil { 1932 return false 1933 } 1934 // If the iterator completed, deliver directly whatever's available 1935 if it.done { 1936 select { 1937 case log := <-it.logs: 1938 it.Event = new(Pancakev3pairInitialize) 1939 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1940 it.fail = err 1941 return false 1942 } 1943 it.Event.Raw = log 1944 return true 1945 1946 default: 1947 return false 1948 } 1949 } 1950 // Iterator still in progress, wait for either a data or an error event 1951 select { 1952 case log := <-it.logs: 1953 it.Event = new(Pancakev3pairInitialize) 1954 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1955 it.fail = err 1956 return false 1957 } 1958 it.Event.Raw = log 1959 return true 1960 1961 case err := <-it.sub.Err(): 1962 it.done = true 1963 it.fail = err 1964 return it.Next() 1965 } 1966 } 1967 1968 // Error returns any retrieval or parsing error occurred during filtering. 1969 func (it *Pancakev3pairInitializeIterator) Error() error { 1970 return it.fail 1971 } 1972 1973 // Close terminates the iteration process, releasing any pending underlying 1974 // resources. 1975 func (it *Pancakev3pairInitializeIterator) Close() error { 1976 it.sub.Unsubscribe() 1977 return nil 1978 } 1979 1980 // Pancakev3pairInitialize represents a Initialize event raised by the Pancakev3pair contract. 1981 type Pancakev3pairInitialize struct { 1982 SqrtPriceX96 *big.Int 1983 Tick *big.Int 1984 Raw types.Log // Blockchain specific contextual infos 1985 } 1986 1987 // FilterInitialize is a free log retrieval operation binding the contract event 0x98636036cb66a9c19a37435efc1e90142190214e8abeb821bdba3f2990dd4c95. 1988 // 1989 // Solidity: event Initialize(uint160 sqrtPriceX96, int24 tick) 1990 func (_Pancakev3pair *Pancakev3pairFilterer) FilterInitialize(opts *bind.FilterOpts) (*Pancakev3pairInitializeIterator, error) { 1991 1992 logs, sub, err := _Pancakev3pair.contract.FilterLogs(opts, "Initialize") 1993 if err != nil { 1994 return nil, err 1995 } 1996 return &Pancakev3pairInitializeIterator{contract: _Pancakev3pair.contract, event: "Initialize", logs: logs, sub: sub}, nil 1997 } 1998 1999 // WatchInitialize is a free log subscription operation binding the contract event 0x98636036cb66a9c19a37435efc1e90142190214e8abeb821bdba3f2990dd4c95. 2000 // 2001 // Solidity: event Initialize(uint160 sqrtPriceX96, int24 tick) 2002 func (_Pancakev3pair *Pancakev3pairFilterer) WatchInitialize(opts *bind.WatchOpts, sink chan<- *Pancakev3pairInitialize) (event.Subscription, error) { 2003 2004 logs, sub, err := _Pancakev3pair.contract.WatchLogs(opts, "Initialize") 2005 if err != nil { 2006 return nil, err 2007 } 2008 return event.NewSubscription(func(quit <-chan struct{}) error { 2009 defer sub.Unsubscribe() 2010 for { 2011 select { 2012 case log := <-logs: 2013 // New log arrived, parse the event and forward to the user 2014 event := new(Pancakev3pairInitialize) 2015 if err := _Pancakev3pair.contract.UnpackLog(event, "Initialize", log); err != nil { 2016 return err 2017 } 2018 event.Raw = log 2019 2020 select { 2021 case sink <- event: 2022 case err := <-sub.Err(): 2023 return err 2024 case <-quit: 2025 return nil 2026 } 2027 case err := <-sub.Err(): 2028 return err 2029 case <-quit: 2030 return nil 2031 } 2032 } 2033 }), nil 2034 } 2035 2036 // ParseInitialize is a log parse operation binding the contract event 0x98636036cb66a9c19a37435efc1e90142190214e8abeb821bdba3f2990dd4c95. 2037 // 2038 // Solidity: event Initialize(uint160 sqrtPriceX96, int24 tick) 2039 func (_Pancakev3pair *Pancakev3pairFilterer) ParseInitialize(log types.Log) (*Pancakev3pairInitialize, error) { 2040 event := new(Pancakev3pairInitialize) 2041 if err := _Pancakev3pair.contract.UnpackLog(event, "Initialize", log); err != nil { 2042 return nil, err 2043 } 2044 event.Raw = log 2045 return event, nil 2046 } 2047 2048 // Pancakev3pairMintIterator is returned from FilterMint and is used to iterate over the raw logs and unpacked data for Mint events raised by the Pancakev3pair contract. 2049 type Pancakev3pairMintIterator struct { 2050 Event *Pancakev3pairMint // Event containing the contract specifics and raw log 2051 2052 contract *bind.BoundContract // Generic contract to use for unpacking event data 2053 event string // Event name to use for unpacking event data 2054 2055 logs chan types.Log // Log channel receiving the found contract events 2056 sub ethereum.Subscription // Subscription for errors, completion and termination 2057 done bool // Whether the subscription completed delivering logs 2058 fail error // Occurred error to stop iteration 2059 } 2060 2061 // Next advances the iterator to the subsequent event, returning whether there 2062 // are any more events found. In case of a retrieval or parsing error, false is 2063 // returned and Error() can be queried for the exact failure. 2064 func (it *Pancakev3pairMintIterator) Next() bool { 2065 // If the iterator failed, stop iterating 2066 if it.fail != nil { 2067 return false 2068 } 2069 // If the iterator completed, deliver directly whatever's available 2070 if it.done { 2071 select { 2072 case log := <-it.logs: 2073 it.Event = new(Pancakev3pairMint) 2074 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2075 it.fail = err 2076 return false 2077 } 2078 it.Event.Raw = log 2079 return true 2080 2081 default: 2082 return false 2083 } 2084 } 2085 // Iterator still in progress, wait for either a data or an error event 2086 select { 2087 case log := <-it.logs: 2088 it.Event = new(Pancakev3pairMint) 2089 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2090 it.fail = err 2091 return false 2092 } 2093 it.Event.Raw = log 2094 return true 2095 2096 case err := <-it.sub.Err(): 2097 it.done = true 2098 it.fail = err 2099 return it.Next() 2100 } 2101 } 2102 2103 // Error returns any retrieval or parsing error occurred during filtering. 2104 func (it *Pancakev3pairMintIterator) Error() error { 2105 return it.fail 2106 } 2107 2108 // Close terminates the iteration process, releasing any pending underlying 2109 // resources. 2110 func (it *Pancakev3pairMintIterator) Close() error { 2111 it.sub.Unsubscribe() 2112 return nil 2113 } 2114 2115 // Pancakev3pairMint represents a Mint event raised by the Pancakev3pair contract. 2116 type Pancakev3pairMint struct { 2117 Sender common.Address 2118 Owner common.Address 2119 TickLower *big.Int 2120 TickUpper *big.Int 2121 Amount *big.Int 2122 Amount0 *big.Int 2123 Amount1 *big.Int 2124 Raw types.Log // Blockchain specific contextual infos 2125 } 2126 2127 // FilterMint is a free log retrieval operation binding the contract event 0x7a53080ba414158be7ec69b987b5fb7d07dee101fe85488f0853ae16239d0bde. 2128 // 2129 // Solidity: event Mint(address sender, address indexed owner, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount, uint256 amount0, uint256 amount1) 2130 func (_Pancakev3pair *Pancakev3pairFilterer) FilterMint(opts *bind.FilterOpts, owner []common.Address, tickLower []*big.Int, tickUpper []*big.Int) (*Pancakev3pairMintIterator, error) { 2131 2132 var ownerRule []interface{} 2133 for _, ownerItem := range owner { 2134 ownerRule = append(ownerRule, ownerItem) 2135 } 2136 var tickLowerRule []interface{} 2137 for _, tickLowerItem := range tickLower { 2138 tickLowerRule = append(tickLowerRule, tickLowerItem) 2139 } 2140 var tickUpperRule []interface{} 2141 for _, tickUpperItem := range tickUpper { 2142 tickUpperRule = append(tickUpperRule, tickUpperItem) 2143 } 2144 2145 logs, sub, err := _Pancakev3pair.contract.FilterLogs(opts, "Mint", ownerRule, tickLowerRule, tickUpperRule) 2146 if err != nil { 2147 return nil, err 2148 } 2149 return &Pancakev3pairMintIterator{contract: _Pancakev3pair.contract, event: "Mint", logs: logs, sub: sub}, nil 2150 } 2151 2152 // WatchMint is a free log subscription operation binding the contract event 0x7a53080ba414158be7ec69b987b5fb7d07dee101fe85488f0853ae16239d0bde. 2153 // 2154 // Solidity: event Mint(address sender, address indexed owner, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount, uint256 amount0, uint256 amount1) 2155 func (_Pancakev3pair *Pancakev3pairFilterer) WatchMint(opts *bind.WatchOpts, sink chan<- *Pancakev3pairMint, owner []common.Address, tickLower []*big.Int, tickUpper []*big.Int) (event.Subscription, error) { 2156 2157 var ownerRule []interface{} 2158 for _, ownerItem := range owner { 2159 ownerRule = append(ownerRule, ownerItem) 2160 } 2161 var tickLowerRule []interface{} 2162 for _, tickLowerItem := range tickLower { 2163 tickLowerRule = append(tickLowerRule, tickLowerItem) 2164 } 2165 var tickUpperRule []interface{} 2166 for _, tickUpperItem := range tickUpper { 2167 tickUpperRule = append(tickUpperRule, tickUpperItem) 2168 } 2169 2170 logs, sub, err := _Pancakev3pair.contract.WatchLogs(opts, "Mint", ownerRule, tickLowerRule, tickUpperRule) 2171 if err != nil { 2172 return nil, err 2173 } 2174 return event.NewSubscription(func(quit <-chan struct{}) error { 2175 defer sub.Unsubscribe() 2176 for { 2177 select { 2178 case log := <-logs: 2179 // New log arrived, parse the event and forward to the user 2180 event := new(Pancakev3pairMint) 2181 if err := _Pancakev3pair.contract.UnpackLog(event, "Mint", log); err != nil { 2182 return err 2183 } 2184 event.Raw = log 2185 2186 select { 2187 case sink <- event: 2188 case err := <-sub.Err(): 2189 return err 2190 case <-quit: 2191 return nil 2192 } 2193 case err := <-sub.Err(): 2194 return err 2195 case <-quit: 2196 return nil 2197 } 2198 } 2199 }), nil 2200 } 2201 2202 // ParseMint is a log parse operation binding the contract event 0x7a53080ba414158be7ec69b987b5fb7d07dee101fe85488f0853ae16239d0bde. 2203 // 2204 // Solidity: event Mint(address sender, address indexed owner, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount, uint256 amount0, uint256 amount1) 2205 func (_Pancakev3pair *Pancakev3pairFilterer) ParseMint(log types.Log) (*Pancakev3pairMint, error) { 2206 event := new(Pancakev3pairMint) 2207 if err := _Pancakev3pair.contract.UnpackLog(event, "Mint", log); err != nil { 2208 return nil, err 2209 } 2210 event.Raw = log 2211 return event, nil 2212 } 2213 2214 // Pancakev3pairSetFeeProtocolIterator is returned from FilterSetFeeProtocol and is used to iterate over the raw logs and unpacked data for SetFeeProtocol events raised by the Pancakev3pair contract. 2215 type Pancakev3pairSetFeeProtocolIterator struct { 2216 Event *Pancakev3pairSetFeeProtocol // Event containing the contract specifics and raw log 2217 2218 contract *bind.BoundContract // Generic contract to use for unpacking event data 2219 event string // Event name to use for unpacking event data 2220 2221 logs chan types.Log // Log channel receiving the found contract events 2222 sub ethereum.Subscription // Subscription for errors, completion and termination 2223 done bool // Whether the subscription completed delivering logs 2224 fail error // Occurred error to stop iteration 2225 } 2226 2227 // Next advances the iterator to the subsequent event, returning whether there 2228 // are any more events found. In case of a retrieval or parsing error, false is 2229 // returned and Error() can be queried for the exact failure. 2230 func (it *Pancakev3pairSetFeeProtocolIterator) Next() bool { 2231 // If the iterator failed, stop iterating 2232 if it.fail != nil { 2233 return false 2234 } 2235 // If the iterator completed, deliver directly whatever's available 2236 if it.done { 2237 select { 2238 case log := <-it.logs: 2239 it.Event = new(Pancakev3pairSetFeeProtocol) 2240 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2241 it.fail = err 2242 return false 2243 } 2244 it.Event.Raw = log 2245 return true 2246 2247 default: 2248 return false 2249 } 2250 } 2251 // Iterator still in progress, wait for either a data or an error event 2252 select { 2253 case log := <-it.logs: 2254 it.Event = new(Pancakev3pairSetFeeProtocol) 2255 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2256 it.fail = err 2257 return false 2258 } 2259 it.Event.Raw = log 2260 return true 2261 2262 case err := <-it.sub.Err(): 2263 it.done = true 2264 it.fail = err 2265 return it.Next() 2266 } 2267 } 2268 2269 // Error returns any retrieval or parsing error occurred during filtering. 2270 func (it *Pancakev3pairSetFeeProtocolIterator) Error() error { 2271 return it.fail 2272 } 2273 2274 // Close terminates the iteration process, releasing any pending underlying 2275 // resources. 2276 func (it *Pancakev3pairSetFeeProtocolIterator) Close() error { 2277 it.sub.Unsubscribe() 2278 return nil 2279 } 2280 2281 // Pancakev3pairSetFeeProtocol represents a SetFeeProtocol event raised by the Pancakev3pair contract. 2282 type Pancakev3pairSetFeeProtocol struct { 2283 FeeProtocol0Old uint32 2284 FeeProtocol1Old uint32 2285 FeeProtocol0New uint32 2286 FeeProtocol1New uint32 2287 Raw types.Log // Blockchain specific contextual infos 2288 } 2289 2290 // FilterSetFeeProtocol is a free log retrieval operation binding the contract event 0xb3159fed3ddfba67bae294599eafe2d0ec98c08bb38e0e5fb87d33154b6e05aa. 2291 // 2292 // Solidity: event SetFeeProtocol(uint32 feeProtocol0Old, uint32 feeProtocol1Old, uint32 feeProtocol0New, uint32 feeProtocol1New) 2293 func (_Pancakev3pair *Pancakev3pairFilterer) FilterSetFeeProtocol(opts *bind.FilterOpts) (*Pancakev3pairSetFeeProtocolIterator, error) { 2294 2295 logs, sub, err := _Pancakev3pair.contract.FilterLogs(opts, "SetFeeProtocol") 2296 if err != nil { 2297 return nil, err 2298 } 2299 return &Pancakev3pairSetFeeProtocolIterator{contract: _Pancakev3pair.contract, event: "SetFeeProtocol", logs: logs, sub: sub}, nil 2300 } 2301 2302 // WatchSetFeeProtocol is a free log subscription operation binding the contract event 0xb3159fed3ddfba67bae294599eafe2d0ec98c08bb38e0e5fb87d33154b6e05aa. 2303 // 2304 // Solidity: event SetFeeProtocol(uint32 feeProtocol0Old, uint32 feeProtocol1Old, uint32 feeProtocol0New, uint32 feeProtocol1New) 2305 func (_Pancakev3pair *Pancakev3pairFilterer) WatchSetFeeProtocol(opts *bind.WatchOpts, sink chan<- *Pancakev3pairSetFeeProtocol) (event.Subscription, error) { 2306 2307 logs, sub, err := _Pancakev3pair.contract.WatchLogs(opts, "SetFeeProtocol") 2308 if err != nil { 2309 return nil, err 2310 } 2311 return event.NewSubscription(func(quit <-chan struct{}) error { 2312 defer sub.Unsubscribe() 2313 for { 2314 select { 2315 case log := <-logs: 2316 // New log arrived, parse the event and forward to the user 2317 event := new(Pancakev3pairSetFeeProtocol) 2318 if err := _Pancakev3pair.contract.UnpackLog(event, "SetFeeProtocol", log); err != nil { 2319 return err 2320 } 2321 event.Raw = log 2322 2323 select { 2324 case sink <- event: 2325 case err := <-sub.Err(): 2326 return err 2327 case <-quit: 2328 return nil 2329 } 2330 case err := <-sub.Err(): 2331 return err 2332 case <-quit: 2333 return nil 2334 } 2335 } 2336 }), nil 2337 } 2338 2339 // ParseSetFeeProtocol is a log parse operation binding the contract event 0xb3159fed3ddfba67bae294599eafe2d0ec98c08bb38e0e5fb87d33154b6e05aa. 2340 // 2341 // Solidity: event SetFeeProtocol(uint32 feeProtocol0Old, uint32 feeProtocol1Old, uint32 feeProtocol0New, uint32 feeProtocol1New) 2342 func (_Pancakev3pair *Pancakev3pairFilterer) ParseSetFeeProtocol(log types.Log) (*Pancakev3pairSetFeeProtocol, error) { 2343 event := new(Pancakev3pairSetFeeProtocol) 2344 if err := _Pancakev3pair.contract.UnpackLog(event, "SetFeeProtocol", log); err != nil { 2345 return nil, err 2346 } 2347 event.Raw = log 2348 return event, nil 2349 } 2350 2351 // Pancakev3pairSetLmPoolEventIterator is returned from FilterSetLmPoolEvent and is used to iterate over the raw logs and unpacked data for SetLmPoolEvent events raised by the Pancakev3pair contract. 2352 type Pancakev3pairSetLmPoolEventIterator struct { 2353 Event *Pancakev3pairSetLmPoolEvent // Event containing the contract specifics and raw log 2354 2355 contract *bind.BoundContract // Generic contract to use for unpacking event data 2356 event string // Event name to use for unpacking event data 2357 2358 logs chan types.Log // Log channel receiving the found contract events 2359 sub ethereum.Subscription // Subscription for errors, completion and termination 2360 done bool // Whether the subscription completed delivering logs 2361 fail error // Occurred error to stop iteration 2362 } 2363 2364 // Next advances the iterator to the subsequent event, returning whether there 2365 // are any more events found. In case of a retrieval or parsing error, false is 2366 // returned and Error() can be queried for the exact failure. 2367 func (it *Pancakev3pairSetLmPoolEventIterator) Next() bool { 2368 // If the iterator failed, stop iterating 2369 if it.fail != nil { 2370 return false 2371 } 2372 // If the iterator completed, deliver directly whatever's available 2373 if it.done { 2374 select { 2375 case log := <-it.logs: 2376 it.Event = new(Pancakev3pairSetLmPoolEvent) 2377 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2378 it.fail = err 2379 return false 2380 } 2381 it.Event.Raw = log 2382 return true 2383 2384 default: 2385 return false 2386 } 2387 } 2388 // Iterator still in progress, wait for either a data or an error event 2389 select { 2390 case log := <-it.logs: 2391 it.Event = new(Pancakev3pairSetLmPoolEvent) 2392 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2393 it.fail = err 2394 return false 2395 } 2396 it.Event.Raw = log 2397 return true 2398 2399 case err := <-it.sub.Err(): 2400 it.done = true 2401 it.fail = err 2402 return it.Next() 2403 } 2404 } 2405 2406 // Error returns any retrieval or parsing error occurred during filtering. 2407 func (it *Pancakev3pairSetLmPoolEventIterator) Error() error { 2408 return it.fail 2409 } 2410 2411 // Close terminates the iteration process, releasing any pending underlying 2412 // resources. 2413 func (it *Pancakev3pairSetLmPoolEventIterator) Close() error { 2414 it.sub.Unsubscribe() 2415 return nil 2416 } 2417 2418 // Pancakev3pairSetLmPoolEvent represents a SetLmPoolEvent event raised by the Pancakev3pair contract. 2419 type Pancakev3pairSetLmPoolEvent struct { 2420 Addr common.Address 2421 Raw types.Log // Blockchain specific contextual infos 2422 } 2423 2424 // FilterSetLmPoolEvent is a free log retrieval operation binding the contract event 0x29983690a85a11696ce8a357993744f8d5a74fde14653e517cc2f8608a7235e9. 2425 // 2426 // Solidity: event SetLmPoolEvent(address addr) 2427 func (_Pancakev3pair *Pancakev3pairFilterer) FilterSetLmPoolEvent(opts *bind.FilterOpts) (*Pancakev3pairSetLmPoolEventIterator, error) { 2428 2429 logs, sub, err := _Pancakev3pair.contract.FilterLogs(opts, "SetLmPoolEvent") 2430 if err != nil { 2431 return nil, err 2432 } 2433 return &Pancakev3pairSetLmPoolEventIterator{contract: _Pancakev3pair.contract, event: "SetLmPoolEvent", logs: logs, sub: sub}, nil 2434 } 2435 2436 // WatchSetLmPoolEvent is a free log subscription operation binding the contract event 0x29983690a85a11696ce8a357993744f8d5a74fde14653e517cc2f8608a7235e9. 2437 // 2438 // Solidity: event SetLmPoolEvent(address addr) 2439 func (_Pancakev3pair *Pancakev3pairFilterer) WatchSetLmPoolEvent(opts *bind.WatchOpts, sink chan<- *Pancakev3pairSetLmPoolEvent) (event.Subscription, error) { 2440 2441 logs, sub, err := _Pancakev3pair.contract.WatchLogs(opts, "SetLmPoolEvent") 2442 if err != nil { 2443 return nil, err 2444 } 2445 return event.NewSubscription(func(quit <-chan struct{}) error { 2446 defer sub.Unsubscribe() 2447 for { 2448 select { 2449 case log := <-logs: 2450 // New log arrived, parse the event and forward to the user 2451 event := new(Pancakev3pairSetLmPoolEvent) 2452 if err := _Pancakev3pair.contract.UnpackLog(event, "SetLmPoolEvent", log); err != nil { 2453 return err 2454 } 2455 event.Raw = log 2456 2457 select { 2458 case sink <- event: 2459 case err := <-sub.Err(): 2460 return err 2461 case <-quit: 2462 return nil 2463 } 2464 case err := <-sub.Err(): 2465 return err 2466 case <-quit: 2467 return nil 2468 } 2469 } 2470 }), nil 2471 } 2472 2473 // ParseSetLmPoolEvent is a log parse operation binding the contract event 0x29983690a85a11696ce8a357993744f8d5a74fde14653e517cc2f8608a7235e9. 2474 // 2475 // Solidity: event SetLmPoolEvent(address addr) 2476 func (_Pancakev3pair *Pancakev3pairFilterer) ParseSetLmPoolEvent(log types.Log) (*Pancakev3pairSetLmPoolEvent, error) { 2477 event := new(Pancakev3pairSetLmPoolEvent) 2478 if err := _Pancakev3pair.contract.UnpackLog(event, "SetLmPoolEvent", log); err != nil { 2479 return nil, err 2480 } 2481 event.Raw = log 2482 return event, nil 2483 } 2484 2485 // Pancakev3pairSwapIterator is returned from FilterSwap and is used to iterate over the raw logs and unpacked data for Swap events raised by the Pancakev3pair contract. 2486 type Pancakev3pairSwapIterator struct { 2487 Event *Pancakev3pairSwap // Event containing the contract specifics and raw log 2488 2489 contract *bind.BoundContract // Generic contract to use for unpacking event data 2490 event string // Event name to use for unpacking event data 2491 2492 logs chan types.Log // Log channel receiving the found contract events 2493 sub ethereum.Subscription // Subscription for errors, completion and termination 2494 done bool // Whether the subscription completed delivering logs 2495 fail error // Occurred error to stop iteration 2496 } 2497 2498 // Next advances the iterator to the subsequent event, returning whether there 2499 // are any more events found. In case of a retrieval or parsing error, false is 2500 // returned and Error() can be queried for the exact failure. 2501 func (it *Pancakev3pairSwapIterator) Next() bool { 2502 // If the iterator failed, stop iterating 2503 if it.fail != nil { 2504 return false 2505 } 2506 // If the iterator completed, deliver directly whatever's available 2507 if it.done { 2508 select { 2509 case log := <-it.logs: 2510 it.Event = new(Pancakev3pairSwap) 2511 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2512 it.fail = err 2513 return false 2514 } 2515 it.Event.Raw = log 2516 return true 2517 2518 default: 2519 return false 2520 } 2521 } 2522 // Iterator still in progress, wait for either a data or an error event 2523 select { 2524 case log := <-it.logs: 2525 it.Event = new(Pancakev3pairSwap) 2526 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2527 it.fail = err 2528 return false 2529 } 2530 it.Event.Raw = log 2531 return true 2532 2533 case err := <-it.sub.Err(): 2534 it.done = true 2535 it.fail = err 2536 return it.Next() 2537 } 2538 } 2539 2540 // Error returns any retrieval or parsing error occurred during filtering. 2541 func (it *Pancakev3pairSwapIterator) Error() error { 2542 return it.fail 2543 } 2544 2545 // Close terminates the iteration process, releasing any pending underlying 2546 // resources. 2547 func (it *Pancakev3pairSwapIterator) Close() error { 2548 it.sub.Unsubscribe() 2549 return nil 2550 } 2551 2552 // Pancakev3pairSwap represents a Swap event raised by the Pancakev3pair contract. 2553 type Pancakev3pairSwap struct { 2554 Sender common.Address 2555 Recipient common.Address 2556 Amount0 *big.Int 2557 Amount1 *big.Int 2558 SqrtPriceX96 *big.Int 2559 Liquidity *big.Int 2560 Tick *big.Int 2561 ProtocolFeesToken0 *big.Int 2562 ProtocolFeesToken1 *big.Int 2563 Raw types.Log // Blockchain specific contextual infos 2564 } 2565 2566 // FilterSwap is a free log retrieval operation binding the contract event 0x19b47279256b2a23a1665c810c8d55a1758940ee09377d4f8d26497a3577dc83. 2567 // 2568 // Solidity: event Swap(address indexed sender, address indexed recipient, int256 amount0, int256 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick, uint128 protocolFeesToken0, uint128 protocolFeesToken1) 2569 func (_Pancakev3pair *Pancakev3pairFilterer) FilterSwap(opts *bind.FilterOpts, sender []common.Address, recipient []common.Address) (*Pancakev3pairSwapIterator, error) { 2570 2571 var senderRule []interface{} 2572 for _, senderItem := range sender { 2573 senderRule = append(senderRule, senderItem) 2574 } 2575 var recipientRule []interface{} 2576 for _, recipientItem := range recipient { 2577 recipientRule = append(recipientRule, recipientItem) 2578 } 2579 2580 logs, sub, err := _Pancakev3pair.contract.FilterLogs(opts, "Swap", senderRule, recipientRule) 2581 if err != nil { 2582 return nil, err 2583 } 2584 return &Pancakev3pairSwapIterator{contract: _Pancakev3pair.contract, event: "Swap", logs: logs, sub: sub}, nil 2585 } 2586 2587 // WatchSwap is a free log subscription operation binding the contract event 0x19b47279256b2a23a1665c810c8d55a1758940ee09377d4f8d26497a3577dc83. 2588 // 2589 // Solidity: event Swap(address indexed sender, address indexed recipient, int256 amount0, int256 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick, uint128 protocolFeesToken0, uint128 protocolFeesToken1) 2590 func (_Pancakev3pair *Pancakev3pairFilterer) WatchSwap(opts *bind.WatchOpts, sink chan<- *Pancakev3pairSwap, sender []common.Address, recipient []common.Address) (event.Subscription, error) { 2591 2592 var senderRule []interface{} 2593 for _, senderItem := range sender { 2594 senderRule = append(senderRule, senderItem) 2595 } 2596 var recipientRule []interface{} 2597 for _, recipientItem := range recipient { 2598 recipientRule = append(recipientRule, recipientItem) 2599 } 2600 2601 logs, sub, err := _Pancakev3pair.contract.WatchLogs(opts, "Swap", senderRule, recipientRule) 2602 if err != nil { 2603 return nil, err 2604 } 2605 return event.NewSubscription(func(quit <-chan struct{}) error { 2606 defer sub.Unsubscribe() 2607 for { 2608 select { 2609 case log := <-logs: 2610 // New log arrived, parse the event and forward to the user 2611 event := new(Pancakev3pairSwap) 2612 if err := _Pancakev3pair.contract.UnpackLog(event, "Swap", log); err != nil { 2613 return err 2614 } 2615 event.Raw = log 2616 2617 select { 2618 case sink <- event: 2619 case err := <-sub.Err(): 2620 return err 2621 case <-quit: 2622 return nil 2623 } 2624 case err := <-sub.Err(): 2625 return err 2626 case <-quit: 2627 return nil 2628 } 2629 } 2630 }), nil 2631 } 2632 2633 // ParseSwap is a log parse operation binding the contract event 0x19b47279256b2a23a1665c810c8d55a1758940ee09377d4f8d26497a3577dc83. 2634 // 2635 // Solidity: event Swap(address indexed sender, address indexed recipient, int256 amount0, int256 amount1, uint160 sqrtPriceX96, uint128 liquidity, int24 tick, uint128 protocolFeesToken0, uint128 protocolFeesToken1) 2636 func (_Pancakev3pair *Pancakev3pairFilterer) ParseSwap(log types.Log) (*Pancakev3pairSwap, error) { 2637 event := new(Pancakev3pairSwap) 2638 if err := _Pancakev3pair.contract.UnpackLog(event, "Swap", log); err != nil { 2639 return nil, err 2640 } 2641 event.Raw = log 2642 return event, nil 2643 }