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