From 0afb017f22789dca390c96f275f7e8ef45484641 Mon Sep 17 00:00:00 2001 From: Laurent Le Houerou Date: Sun, 14 Nov 2021 23:08:53 +0400 Subject: [PATCH] curve + aave + beefy --- aave/contracts/IDataProvider.abi | 1 + aave/contracts/IIncentivesController.abi | 1 + aave/contracts/ILendingPool.abi | 1 + aave/contracts/dataprovider.go | 310 ++ aave/contracts/incentivescontroller.go | 232 ++ aave/contracts/lendingpool.go | 329 +++ curve/contracts/pool.go | 3341 ++++++++++++++++++++++ 7 files changed, 4215 insertions(+) create mode 100644 aave/contracts/IDataProvider.abi create mode 100644 aave/contracts/IIncentivesController.abi create mode 100644 aave/contracts/ILendingPool.abi create mode 100644 aave/contracts/dataprovider.go create mode 100644 aave/contracts/incentivescontroller.go create mode 100644 aave/contracts/lendingpool.go create mode 100644 curve/contracts/pool.go diff --git a/aave/contracts/IDataProvider.abi b/aave/contracts/IDataProvider.abi new file mode 100644 index 0000000..b6b68b1 --- /dev/null +++ b/aave/contracts/IDataProvider.abi @@ -0,0 +1 @@ +[{"inputs":[{"internalType":"address","name":"asset","type":"address"}],"name":"getReserveTokensAddresses","outputs":[{"internalType":"address","name":"aTokenAddress","type":"address"},{"internalType":"address","name":"stableDebtTokenAddress","type":"address"},{"internalType":"address","name":"variableDebtTokenAddress","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"asset","type":"address"},{"internalType":"address","name":"user","type":"address"}],"name":"getUserReserveData","outputs":[{"internalType":"uint256","name":"currentATokenBalance","type":"uint256"},{"internalType":"uint256","name":"currentStableDebt","type":"uint256"},{"internalType":"uint256","name":"currentVariableDebt","type":"uint256"},{"internalType":"uint256","name":"principalStableDebt","type":"uint256"},{"internalType":"uint256","name":"scaledVariableDebt","type":"uint256"},{"internalType":"uint256","name":"stableBorrowRate","type":"uint256"},{"internalType":"uint256","name":"liquidityRate","type":"uint256"},{"internalType":"uint40","name":"stableRateLastUpdated","type":"uint40"},{"internalType":"bool","name":"usageAsCollateralEnabled","type":"bool"}],"stateMutability":"view","type":"function"}] \ No newline at end of file diff --git a/aave/contracts/IIncentivesController.abi b/aave/contracts/IIncentivesController.abi new file mode 100644 index 0000000..140e845 --- /dev/null +++ b/aave/contracts/IIncentivesController.abi @@ -0,0 +1 @@ +[{"inputs":[{"internalType":"address[]","name":"assets","type":"address[]"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"claimRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"assets","type":"address[]"},{"internalType":"address","name":"user","type":"address"}],"name":"getRewardsBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}] \ No newline at end of file diff --git a/aave/contracts/ILendingPool.abi b/aave/contracts/ILendingPool.abi new file mode 100644 index 0000000..847aae1 --- /dev/null +++ b/aave/contracts/ILendingPool.abi @@ -0,0 +1 @@ +[{"inputs":[{"internalType":"address","name":"asset","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"interestRateMode","type":"uint256"},{"internalType":"uint16","name":"referralCode","type":"uint16"},{"internalType":"address","name":"onBehalfOf","type":"address"}],"name":"borrow","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"asset","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"onBehalfOf","type":"address"},{"internalType":"uint16","name":"referralCode","type":"uint16"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getUserAccountData","outputs":[{"internalType":"uint256","name":"totalCollateralETH","type":"uint256"},{"internalType":"uint256","name":"totalDebtETH","type":"uint256"},{"internalType":"uint256","name":"availableBorrowsETH","type":"uint256"},{"internalType":"uint256","name":"currentLiquidationThreshold","type":"uint256"},{"internalType":"uint256","name":"ltv","type":"uint256"},{"internalType":"uint256","name":"healthFactor","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"asset","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rateMode","type":"uint256"},{"internalType":"address","name":"onBehalfOf","type":"address"}],"name":"repay","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"asset","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}] \ No newline at end of file diff --git a/aave/contracts/dataprovider.go b/aave/contracts/dataprovider.go new file mode 100644 index 0000000..f20c1b0 --- /dev/null +++ b/aave/contracts/dataprovider.go @@ -0,0 +1,310 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package contracts + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription +) + +// DataProviderMetaData contains all meta data concerning the DataProvider contract. +var DataProviderMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"getReserveTokensAddresses\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"aTokenAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"stableDebtTokenAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"variableDebtTokenAddress\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"}],\"name\":\"getUserReserveData\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"currentATokenBalance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"currentStableDebt\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"currentVariableDebt\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"principalStableDebt\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"scaledVariableDebt\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"stableBorrowRate\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"liquidityRate\",\"type\":\"uint256\"},{\"internalType\":\"uint40\",\"name\":\"stableRateLastUpdated\",\"type\":\"uint40\"},{\"internalType\":\"bool\",\"name\":\"usageAsCollateralEnabled\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", +} + +// DataProviderABI is the input ABI used to generate the binding from. +// Deprecated: Use DataProviderMetaData.ABI instead. +var DataProviderABI = DataProviderMetaData.ABI + +// DataProvider is an auto generated Go binding around an Ethereum contract. +type DataProvider struct { + DataProviderCaller // Read-only binding to the contract + DataProviderTransactor // Write-only binding to the contract + DataProviderFilterer // Log filterer for contract events +} + +// DataProviderCaller is an auto generated read-only Go binding around an Ethereum contract. +type DataProviderCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// DataProviderTransactor is an auto generated write-only Go binding around an Ethereum contract. +type DataProviderTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// DataProviderFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type DataProviderFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// DataProviderSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type DataProviderSession struct { + Contract *DataProvider // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// DataProviderCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type DataProviderCallerSession struct { + Contract *DataProviderCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// DataProviderTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type DataProviderTransactorSession struct { + Contract *DataProviderTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// DataProviderRaw is an auto generated low-level Go binding around an Ethereum contract. +type DataProviderRaw struct { + Contract *DataProvider // Generic contract binding to access the raw methods on +} + +// DataProviderCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type DataProviderCallerRaw struct { + Contract *DataProviderCaller // Generic read-only contract binding to access the raw methods on +} + +// DataProviderTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type DataProviderTransactorRaw struct { + Contract *DataProviderTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewDataProvider creates a new instance of DataProvider, bound to a specific deployed contract. +func NewDataProvider(address common.Address, backend bind.ContractBackend) (*DataProvider, error) { + contract, err := bindDataProvider(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &DataProvider{DataProviderCaller: DataProviderCaller{contract: contract}, DataProviderTransactor: DataProviderTransactor{contract: contract}, DataProviderFilterer: DataProviderFilterer{contract: contract}}, nil +} + +// NewDataProviderCaller creates a new read-only instance of DataProvider, bound to a specific deployed contract. +func NewDataProviderCaller(address common.Address, caller bind.ContractCaller) (*DataProviderCaller, error) { + contract, err := bindDataProvider(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &DataProviderCaller{contract: contract}, nil +} + +// NewDataProviderTransactor creates a new write-only instance of DataProvider, bound to a specific deployed contract. +func NewDataProviderTransactor(address common.Address, transactor bind.ContractTransactor) (*DataProviderTransactor, error) { + contract, err := bindDataProvider(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &DataProviderTransactor{contract: contract}, nil +} + +// NewDataProviderFilterer creates a new log filterer instance of DataProvider, bound to a specific deployed contract. +func NewDataProviderFilterer(address common.Address, filterer bind.ContractFilterer) (*DataProviderFilterer, error) { + contract, err := bindDataProvider(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &DataProviderFilterer{contract: contract}, nil +} + +// bindDataProvider binds a generic wrapper to an already deployed contract. +func bindDataProvider(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader(DataProviderABI)) + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_DataProvider *DataProviderRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _DataProvider.Contract.DataProviderCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_DataProvider *DataProviderRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _DataProvider.Contract.DataProviderTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_DataProvider *DataProviderRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _DataProvider.Contract.DataProviderTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_DataProvider *DataProviderCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _DataProvider.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_DataProvider *DataProviderTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _DataProvider.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_DataProvider *DataProviderTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _DataProvider.Contract.contract.Transact(opts, method, params...) +} + +// GetReserveTokensAddresses is a free data retrieval call binding the contract method 0xd2493b6c. +// +// Solidity: function getReserveTokensAddresses(address asset) view returns(address aTokenAddress, address stableDebtTokenAddress, address variableDebtTokenAddress) +func (_DataProvider *DataProviderCaller) GetReserveTokensAddresses(opts *bind.CallOpts, asset common.Address) (struct { + ATokenAddress common.Address + StableDebtTokenAddress common.Address + VariableDebtTokenAddress common.Address +}, error) { + var out []interface{} + err := _DataProvider.contract.Call(opts, &out, "getReserveTokensAddresses", asset) + + outstruct := new(struct { + ATokenAddress common.Address + StableDebtTokenAddress common.Address + VariableDebtTokenAddress common.Address + }) + if err != nil { + return *outstruct, err + } + + outstruct.ATokenAddress = *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + outstruct.StableDebtTokenAddress = *abi.ConvertType(out[1], new(common.Address)).(*common.Address) + outstruct.VariableDebtTokenAddress = *abi.ConvertType(out[2], new(common.Address)).(*common.Address) + + return *outstruct, err + +} + +// GetReserveTokensAddresses is a free data retrieval call binding the contract method 0xd2493b6c. +// +// Solidity: function getReserveTokensAddresses(address asset) view returns(address aTokenAddress, address stableDebtTokenAddress, address variableDebtTokenAddress) +func (_DataProvider *DataProviderSession) GetReserveTokensAddresses(asset common.Address) (struct { + ATokenAddress common.Address + StableDebtTokenAddress common.Address + VariableDebtTokenAddress common.Address +}, error) { + return _DataProvider.Contract.GetReserveTokensAddresses(&_DataProvider.CallOpts, asset) +} + +// GetReserveTokensAddresses is a free data retrieval call binding the contract method 0xd2493b6c. +// +// Solidity: function getReserveTokensAddresses(address asset) view returns(address aTokenAddress, address stableDebtTokenAddress, address variableDebtTokenAddress) +func (_DataProvider *DataProviderCallerSession) GetReserveTokensAddresses(asset common.Address) (struct { + ATokenAddress common.Address + StableDebtTokenAddress common.Address + VariableDebtTokenAddress common.Address +}, error) { + return _DataProvider.Contract.GetReserveTokensAddresses(&_DataProvider.CallOpts, asset) +} + +// GetUserReserveData is a free data retrieval call binding the contract method 0x28dd2d01. +// +// Solidity: function getUserReserveData(address asset, address user) view returns(uint256 currentATokenBalance, uint256 currentStableDebt, uint256 currentVariableDebt, uint256 principalStableDebt, uint256 scaledVariableDebt, uint256 stableBorrowRate, uint256 liquidityRate, uint40 stableRateLastUpdated, bool usageAsCollateralEnabled) +func (_DataProvider *DataProviderCaller) GetUserReserveData(opts *bind.CallOpts, asset common.Address, user common.Address) (struct { + CurrentATokenBalance *big.Int + CurrentStableDebt *big.Int + CurrentVariableDebt *big.Int + PrincipalStableDebt *big.Int + ScaledVariableDebt *big.Int + StableBorrowRate *big.Int + LiquidityRate *big.Int + StableRateLastUpdated *big.Int + UsageAsCollateralEnabled bool +}, error) { + var out []interface{} + err := _DataProvider.contract.Call(opts, &out, "getUserReserveData", asset, user) + + outstruct := new(struct { + CurrentATokenBalance *big.Int + CurrentStableDebt *big.Int + CurrentVariableDebt *big.Int + PrincipalStableDebt *big.Int + ScaledVariableDebt *big.Int + StableBorrowRate *big.Int + LiquidityRate *big.Int + StableRateLastUpdated *big.Int + UsageAsCollateralEnabled bool + }) + if err != nil { + return *outstruct, err + } + + outstruct.CurrentATokenBalance = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.CurrentStableDebt = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + outstruct.CurrentVariableDebt = *abi.ConvertType(out[2], new(*big.Int)).(**big.Int) + outstruct.PrincipalStableDebt = *abi.ConvertType(out[3], new(*big.Int)).(**big.Int) + outstruct.ScaledVariableDebt = *abi.ConvertType(out[4], new(*big.Int)).(**big.Int) + outstruct.StableBorrowRate = *abi.ConvertType(out[5], new(*big.Int)).(**big.Int) + outstruct.LiquidityRate = *abi.ConvertType(out[6], new(*big.Int)).(**big.Int) + outstruct.StableRateLastUpdated = *abi.ConvertType(out[7], new(*big.Int)).(**big.Int) + outstruct.UsageAsCollateralEnabled = *abi.ConvertType(out[8], new(bool)).(*bool) + + return *outstruct, err + +} + +// GetUserReserveData is a free data retrieval call binding the contract method 0x28dd2d01. +// +// Solidity: function getUserReserveData(address asset, address user) view returns(uint256 currentATokenBalance, uint256 currentStableDebt, uint256 currentVariableDebt, uint256 principalStableDebt, uint256 scaledVariableDebt, uint256 stableBorrowRate, uint256 liquidityRate, uint40 stableRateLastUpdated, bool usageAsCollateralEnabled) +func (_DataProvider *DataProviderSession) GetUserReserveData(asset common.Address, user common.Address) (struct { + CurrentATokenBalance *big.Int + CurrentStableDebt *big.Int + CurrentVariableDebt *big.Int + PrincipalStableDebt *big.Int + ScaledVariableDebt *big.Int + StableBorrowRate *big.Int + LiquidityRate *big.Int + StableRateLastUpdated *big.Int + UsageAsCollateralEnabled bool +}, error) { + return _DataProvider.Contract.GetUserReserveData(&_DataProvider.CallOpts, asset, user) +} + +// GetUserReserveData is a free data retrieval call binding the contract method 0x28dd2d01. +// +// Solidity: function getUserReserveData(address asset, address user) view returns(uint256 currentATokenBalance, uint256 currentStableDebt, uint256 currentVariableDebt, uint256 principalStableDebt, uint256 scaledVariableDebt, uint256 stableBorrowRate, uint256 liquidityRate, uint40 stableRateLastUpdated, bool usageAsCollateralEnabled) +func (_DataProvider *DataProviderCallerSession) GetUserReserveData(asset common.Address, user common.Address) (struct { + CurrentATokenBalance *big.Int + CurrentStableDebt *big.Int + CurrentVariableDebt *big.Int + PrincipalStableDebt *big.Int + ScaledVariableDebt *big.Int + StableBorrowRate *big.Int + LiquidityRate *big.Int + StableRateLastUpdated *big.Int + UsageAsCollateralEnabled bool +}, error) { + return _DataProvider.Contract.GetUserReserveData(&_DataProvider.CallOpts, asset, user) +} diff --git a/aave/contracts/incentivescontroller.go b/aave/contracts/incentivescontroller.go new file mode 100644 index 0000000..38aa416 --- /dev/null +++ b/aave/contracts/incentivescontroller.go @@ -0,0 +1,232 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package contracts + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription +) + +// IncentivesControllerMetaData contains all meta data concerning the IncentivesController contract. +var IncentivesControllerMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"assets\",\"type\":\"address[]\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"claimRewards\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"assets\",\"type\":\"address[]\"},{\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"}],\"name\":\"getRewardsBalance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", +} + +// IncentivesControllerABI is the input ABI used to generate the binding from. +// Deprecated: Use IncentivesControllerMetaData.ABI instead. +var IncentivesControllerABI = IncentivesControllerMetaData.ABI + +// IncentivesController is an auto generated Go binding around an Ethereum contract. +type IncentivesController struct { + IncentivesControllerCaller // Read-only binding to the contract + IncentivesControllerTransactor // Write-only binding to the contract + IncentivesControllerFilterer // Log filterer for contract events +} + +// IncentivesControllerCaller is an auto generated read-only Go binding around an Ethereum contract. +type IncentivesControllerCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IncentivesControllerTransactor is an auto generated write-only Go binding around an Ethereum contract. +type IncentivesControllerTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IncentivesControllerFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type IncentivesControllerFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IncentivesControllerSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type IncentivesControllerSession struct { + Contract *IncentivesController // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IncentivesControllerCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type IncentivesControllerCallerSession struct { + Contract *IncentivesControllerCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// IncentivesControllerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type IncentivesControllerTransactorSession struct { + Contract *IncentivesControllerTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IncentivesControllerRaw is an auto generated low-level Go binding around an Ethereum contract. +type IncentivesControllerRaw struct { + Contract *IncentivesController // Generic contract binding to access the raw methods on +} + +// IncentivesControllerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type IncentivesControllerCallerRaw struct { + Contract *IncentivesControllerCaller // Generic read-only contract binding to access the raw methods on +} + +// IncentivesControllerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type IncentivesControllerTransactorRaw struct { + Contract *IncentivesControllerTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewIncentivesController creates a new instance of IncentivesController, bound to a specific deployed contract. +func NewIncentivesController(address common.Address, backend bind.ContractBackend) (*IncentivesController, error) { + contract, err := bindIncentivesController(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &IncentivesController{IncentivesControllerCaller: IncentivesControllerCaller{contract: contract}, IncentivesControllerTransactor: IncentivesControllerTransactor{contract: contract}, IncentivesControllerFilterer: IncentivesControllerFilterer{contract: contract}}, nil +} + +// NewIncentivesControllerCaller creates a new read-only instance of IncentivesController, bound to a specific deployed contract. +func NewIncentivesControllerCaller(address common.Address, caller bind.ContractCaller) (*IncentivesControllerCaller, error) { + contract, err := bindIncentivesController(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &IncentivesControllerCaller{contract: contract}, nil +} + +// NewIncentivesControllerTransactor creates a new write-only instance of IncentivesController, bound to a specific deployed contract. +func NewIncentivesControllerTransactor(address common.Address, transactor bind.ContractTransactor) (*IncentivesControllerTransactor, error) { + contract, err := bindIncentivesController(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &IncentivesControllerTransactor{contract: contract}, nil +} + +// NewIncentivesControllerFilterer creates a new log filterer instance of IncentivesController, bound to a specific deployed contract. +func NewIncentivesControllerFilterer(address common.Address, filterer bind.ContractFilterer) (*IncentivesControllerFilterer, error) { + contract, err := bindIncentivesController(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &IncentivesControllerFilterer{contract: contract}, nil +} + +// bindIncentivesController binds a generic wrapper to an already deployed contract. +func bindIncentivesController(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader(IncentivesControllerABI)) + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IncentivesController *IncentivesControllerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IncentivesController.Contract.IncentivesControllerCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IncentivesController *IncentivesControllerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IncentivesController.Contract.IncentivesControllerTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IncentivesController *IncentivesControllerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IncentivesController.Contract.IncentivesControllerTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IncentivesController *IncentivesControllerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IncentivesController.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IncentivesController *IncentivesControllerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IncentivesController.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IncentivesController *IncentivesControllerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IncentivesController.Contract.contract.Transact(opts, method, params...) +} + +// GetRewardsBalance is a free data retrieval call binding the contract method 0x8b599f26. +// +// Solidity: function getRewardsBalance(address[] assets, address user) view returns(uint256) +func (_IncentivesController *IncentivesControllerCaller) GetRewardsBalance(opts *bind.CallOpts, assets []common.Address, user common.Address) (*big.Int, error) { + var out []interface{} + err := _IncentivesController.contract.Call(opts, &out, "getRewardsBalance", assets, user) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetRewardsBalance is a free data retrieval call binding the contract method 0x8b599f26. +// +// Solidity: function getRewardsBalance(address[] assets, address user) view returns(uint256) +func (_IncentivesController *IncentivesControllerSession) GetRewardsBalance(assets []common.Address, user common.Address) (*big.Int, error) { + return _IncentivesController.Contract.GetRewardsBalance(&_IncentivesController.CallOpts, assets, user) +} + +// GetRewardsBalance is a free data retrieval call binding the contract method 0x8b599f26. +// +// Solidity: function getRewardsBalance(address[] assets, address user) view returns(uint256) +func (_IncentivesController *IncentivesControllerCallerSession) GetRewardsBalance(assets []common.Address, user common.Address) (*big.Int, error) { + return _IncentivesController.Contract.GetRewardsBalance(&_IncentivesController.CallOpts, assets, user) +} + +// ClaimRewards is a paid mutator transaction binding the contract method 0x3111e7b3. +// +// Solidity: function claimRewards(address[] assets, uint256 amount, address to) returns(uint256) +func (_IncentivesController *IncentivesControllerTransactor) ClaimRewards(opts *bind.TransactOpts, assets []common.Address, amount *big.Int, to common.Address) (*types.Transaction, error) { + return _IncentivesController.contract.Transact(opts, "claimRewards", assets, amount, to) +} + +// ClaimRewards is a paid mutator transaction binding the contract method 0x3111e7b3. +// +// Solidity: function claimRewards(address[] assets, uint256 amount, address to) returns(uint256) +func (_IncentivesController *IncentivesControllerSession) ClaimRewards(assets []common.Address, amount *big.Int, to common.Address) (*types.Transaction, error) { + return _IncentivesController.Contract.ClaimRewards(&_IncentivesController.TransactOpts, assets, amount, to) +} + +// ClaimRewards is a paid mutator transaction binding the contract method 0x3111e7b3. +// +// Solidity: function claimRewards(address[] assets, uint256 amount, address to) returns(uint256) +func (_IncentivesController *IncentivesControllerTransactorSession) ClaimRewards(assets []common.Address, amount *big.Int, to common.Address) (*types.Transaction, error) { + return _IncentivesController.Contract.ClaimRewards(&_IncentivesController.TransactOpts, assets, amount, to) +} diff --git a/aave/contracts/lendingpool.go b/aave/contracts/lendingpool.go new file mode 100644 index 0000000..7f6e2e4 --- /dev/null +++ b/aave/contracts/lendingpool.go @@ -0,0 +1,329 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package contracts + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription +) + +// LendingPoolMetaData contains all meta data concerning the LendingPool contract. +var LendingPoolMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"interestRateMode\",\"type\":\"uint256\"},{\"internalType\":\"uint16\",\"name\":\"referralCode\",\"type\":\"uint16\"},{\"internalType\":\"address\",\"name\":\"onBehalfOf\",\"type\":\"address\"}],\"name\":\"borrow\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"onBehalfOf\",\"type\":\"address\"},{\"internalType\":\"uint16\",\"name\":\"referralCode\",\"type\":\"uint16\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"}],\"name\":\"getUserAccountData\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"totalCollateralETH\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalDebtETH\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"availableBorrowsETH\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"currentLiquidationThreshold\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"ltv\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"healthFactor\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"rateMode\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"onBehalfOf\",\"type\":\"address\"}],\"name\":\"repay\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", +} + +// LendingPoolABI is the input ABI used to generate the binding from. +// Deprecated: Use LendingPoolMetaData.ABI instead. +var LendingPoolABI = LendingPoolMetaData.ABI + +// LendingPool is an auto generated Go binding around an Ethereum contract. +type LendingPool struct { + LendingPoolCaller // Read-only binding to the contract + LendingPoolTransactor // Write-only binding to the contract + LendingPoolFilterer // Log filterer for contract events +} + +// LendingPoolCaller is an auto generated read-only Go binding around an Ethereum contract. +type LendingPoolCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// LendingPoolTransactor is an auto generated write-only Go binding around an Ethereum contract. +type LendingPoolTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// LendingPoolFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type LendingPoolFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// LendingPoolSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type LendingPoolSession struct { + Contract *LendingPool // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// LendingPoolCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type LendingPoolCallerSession struct { + Contract *LendingPoolCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// LendingPoolTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type LendingPoolTransactorSession struct { + Contract *LendingPoolTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// LendingPoolRaw is an auto generated low-level Go binding around an Ethereum contract. +type LendingPoolRaw struct { + Contract *LendingPool // Generic contract binding to access the raw methods on +} + +// LendingPoolCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type LendingPoolCallerRaw struct { + Contract *LendingPoolCaller // Generic read-only contract binding to access the raw methods on +} + +// LendingPoolTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type LendingPoolTransactorRaw struct { + Contract *LendingPoolTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewLendingPool creates a new instance of LendingPool, bound to a specific deployed contract. +func NewLendingPool(address common.Address, backend bind.ContractBackend) (*LendingPool, error) { + contract, err := bindLendingPool(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &LendingPool{LendingPoolCaller: LendingPoolCaller{contract: contract}, LendingPoolTransactor: LendingPoolTransactor{contract: contract}, LendingPoolFilterer: LendingPoolFilterer{contract: contract}}, nil +} + +// NewLendingPoolCaller creates a new read-only instance of LendingPool, bound to a specific deployed contract. +func NewLendingPoolCaller(address common.Address, caller bind.ContractCaller) (*LendingPoolCaller, error) { + contract, err := bindLendingPool(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &LendingPoolCaller{contract: contract}, nil +} + +// NewLendingPoolTransactor creates a new write-only instance of LendingPool, bound to a specific deployed contract. +func NewLendingPoolTransactor(address common.Address, transactor bind.ContractTransactor) (*LendingPoolTransactor, error) { + contract, err := bindLendingPool(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &LendingPoolTransactor{contract: contract}, nil +} + +// NewLendingPoolFilterer creates a new log filterer instance of LendingPool, bound to a specific deployed contract. +func NewLendingPoolFilterer(address common.Address, filterer bind.ContractFilterer) (*LendingPoolFilterer, error) { + contract, err := bindLendingPool(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &LendingPoolFilterer{contract: contract}, nil +} + +// bindLendingPool binds a generic wrapper to an already deployed contract. +func bindLendingPool(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader(LendingPoolABI)) + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_LendingPool *LendingPoolRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _LendingPool.Contract.LendingPoolCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_LendingPool *LendingPoolRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _LendingPool.Contract.LendingPoolTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_LendingPool *LendingPoolRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _LendingPool.Contract.LendingPoolTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_LendingPool *LendingPoolCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _LendingPool.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_LendingPool *LendingPoolTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _LendingPool.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_LendingPool *LendingPoolTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _LendingPool.Contract.contract.Transact(opts, method, params...) +} + +// GetUserAccountData is a free data retrieval call binding the contract method 0xbf92857c. +// +// Solidity: function getUserAccountData(address user) view returns(uint256 totalCollateralETH, uint256 totalDebtETH, uint256 availableBorrowsETH, uint256 currentLiquidationThreshold, uint256 ltv, uint256 healthFactor) +func (_LendingPool *LendingPoolCaller) GetUserAccountData(opts *bind.CallOpts, user common.Address) (struct { + TotalCollateralETH *big.Int + TotalDebtETH *big.Int + AvailableBorrowsETH *big.Int + CurrentLiquidationThreshold *big.Int + Ltv *big.Int + HealthFactor *big.Int +}, error) { + var out []interface{} + err := _LendingPool.contract.Call(opts, &out, "getUserAccountData", user) + + outstruct := new(struct { + TotalCollateralETH *big.Int + TotalDebtETH *big.Int + AvailableBorrowsETH *big.Int + CurrentLiquidationThreshold *big.Int + Ltv *big.Int + HealthFactor *big.Int + }) + if err != nil { + return *outstruct, err + } + + outstruct.TotalCollateralETH = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.TotalDebtETH = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + outstruct.AvailableBorrowsETH = *abi.ConvertType(out[2], new(*big.Int)).(**big.Int) + outstruct.CurrentLiquidationThreshold = *abi.ConvertType(out[3], new(*big.Int)).(**big.Int) + outstruct.Ltv = *abi.ConvertType(out[4], new(*big.Int)).(**big.Int) + outstruct.HealthFactor = *abi.ConvertType(out[5], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// GetUserAccountData is a free data retrieval call binding the contract method 0xbf92857c. +// +// Solidity: function getUserAccountData(address user) view returns(uint256 totalCollateralETH, uint256 totalDebtETH, uint256 availableBorrowsETH, uint256 currentLiquidationThreshold, uint256 ltv, uint256 healthFactor) +func (_LendingPool *LendingPoolSession) GetUserAccountData(user common.Address) (struct { + TotalCollateralETH *big.Int + TotalDebtETH *big.Int + AvailableBorrowsETH *big.Int + CurrentLiquidationThreshold *big.Int + Ltv *big.Int + HealthFactor *big.Int +}, error) { + return _LendingPool.Contract.GetUserAccountData(&_LendingPool.CallOpts, user) +} + +// GetUserAccountData is a free data retrieval call binding the contract method 0xbf92857c. +// +// Solidity: function getUserAccountData(address user) view returns(uint256 totalCollateralETH, uint256 totalDebtETH, uint256 availableBorrowsETH, uint256 currentLiquidationThreshold, uint256 ltv, uint256 healthFactor) +func (_LendingPool *LendingPoolCallerSession) GetUserAccountData(user common.Address) (struct { + TotalCollateralETH *big.Int + TotalDebtETH *big.Int + AvailableBorrowsETH *big.Int + CurrentLiquidationThreshold *big.Int + Ltv *big.Int + HealthFactor *big.Int +}, error) { + return _LendingPool.Contract.GetUserAccountData(&_LendingPool.CallOpts, user) +} + +// Borrow is a paid mutator transaction binding the contract method 0xa415bcad. +// +// Solidity: function borrow(address asset, uint256 amount, uint256 interestRateMode, uint16 referralCode, address onBehalfOf) returns() +func (_LendingPool *LendingPoolTransactor) Borrow(opts *bind.TransactOpts, asset common.Address, amount *big.Int, interestRateMode *big.Int, referralCode uint16, onBehalfOf common.Address) (*types.Transaction, error) { + return _LendingPool.contract.Transact(opts, "borrow", asset, amount, interestRateMode, referralCode, onBehalfOf) +} + +// Borrow is a paid mutator transaction binding the contract method 0xa415bcad. +// +// Solidity: function borrow(address asset, uint256 amount, uint256 interestRateMode, uint16 referralCode, address onBehalfOf) returns() +func (_LendingPool *LendingPoolSession) Borrow(asset common.Address, amount *big.Int, interestRateMode *big.Int, referralCode uint16, onBehalfOf common.Address) (*types.Transaction, error) { + return _LendingPool.Contract.Borrow(&_LendingPool.TransactOpts, asset, amount, interestRateMode, referralCode, onBehalfOf) +} + +// Borrow is a paid mutator transaction binding the contract method 0xa415bcad. +// +// Solidity: function borrow(address asset, uint256 amount, uint256 interestRateMode, uint16 referralCode, address onBehalfOf) returns() +func (_LendingPool *LendingPoolTransactorSession) Borrow(asset common.Address, amount *big.Int, interestRateMode *big.Int, referralCode uint16, onBehalfOf common.Address) (*types.Transaction, error) { + return _LendingPool.Contract.Borrow(&_LendingPool.TransactOpts, asset, amount, interestRateMode, referralCode, onBehalfOf) +} + +// Deposit is a paid mutator transaction binding the contract method 0xe8eda9df. +// +// Solidity: function deposit(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) returns() +func (_LendingPool *LendingPoolTransactor) Deposit(opts *bind.TransactOpts, asset common.Address, amount *big.Int, onBehalfOf common.Address, referralCode uint16) (*types.Transaction, error) { + return _LendingPool.contract.Transact(opts, "deposit", asset, amount, onBehalfOf, referralCode) +} + +// Deposit is a paid mutator transaction binding the contract method 0xe8eda9df. +// +// Solidity: function deposit(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) returns() +func (_LendingPool *LendingPoolSession) Deposit(asset common.Address, amount *big.Int, onBehalfOf common.Address, referralCode uint16) (*types.Transaction, error) { + return _LendingPool.Contract.Deposit(&_LendingPool.TransactOpts, asset, amount, onBehalfOf, referralCode) +} + +// Deposit is a paid mutator transaction binding the contract method 0xe8eda9df. +// +// Solidity: function deposit(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) returns() +func (_LendingPool *LendingPoolTransactorSession) Deposit(asset common.Address, amount *big.Int, onBehalfOf common.Address, referralCode uint16) (*types.Transaction, error) { + return _LendingPool.Contract.Deposit(&_LendingPool.TransactOpts, asset, amount, onBehalfOf, referralCode) +} + +// Repay is a paid mutator transaction binding the contract method 0x573ade81. +// +// Solidity: function repay(address asset, uint256 amount, uint256 rateMode, address onBehalfOf) returns(uint256) +func (_LendingPool *LendingPoolTransactor) Repay(opts *bind.TransactOpts, asset common.Address, amount *big.Int, rateMode *big.Int, onBehalfOf common.Address) (*types.Transaction, error) { + return _LendingPool.contract.Transact(opts, "repay", asset, amount, rateMode, onBehalfOf) +} + +// Repay is a paid mutator transaction binding the contract method 0x573ade81. +// +// Solidity: function repay(address asset, uint256 amount, uint256 rateMode, address onBehalfOf) returns(uint256) +func (_LendingPool *LendingPoolSession) Repay(asset common.Address, amount *big.Int, rateMode *big.Int, onBehalfOf common.Address) (*types.Transaction, error) { + return _LendingPool.Contract.Repay(&_LendingPool.TransactOpts, asset, amount, rateMode, onBehalfOf) +} + +// Repay is a paid mutator transaction binding the contract method 0x573ade81. +// +// Solidity: function repay(address asset, uint256 amount, uint256 rateMode, address onBehalfOf) returns(uint256) +func (_LendingPool *LendingPoolTransactorSession) Repay(asset common.Address, amount *big.Int, rateMode *big.Int, onBehalfOf common.Address) (*types.Transaction, error) { + return _LendingPool.Contract.Repay(&_LendingPool.TransactOpts, asset, amount, rateMode, onBehalfOf) +} + +// Withdraw is a paid mutator transaction binding the contract method 0x69328dec. +// +// Solidity: function withdraw(address asset, uint256 amount, address to) returns(uint256) +func (_LendingPool *LendingPoolTransactor) Withdraw(opts *bind.TransactOpts, asset common.Address, amount *big.Int, to common.Address) (*types.Transaction, error) { + return _LendingPool.contract.Transact(opts, "withdraw", asset, amount, to) +} + +// Withdraw is a paid mutator transaction binding the contract method 0x69328dec. +// +// Solidity: function withdraw(address asset, uint256 amount, address to) returns(uint256) +func (_LendingPool *LendingPoolSession) Withdraw(asset common.Address, amount *big.Int, to common.Address) (*types.Transaction, error) { + return _LendingPool.Contract.Withdraw(&_LendingPool.TransactOpts, asset, amount, to) +} + +// Withdraw is a paid mutator transaction binding the contract method 0x69328dec. +// +// Solidity: function withdraw(address asset, uint256 amount, address to) returns(uint256) +func (_LendingPool *LendingPoolTransactorSession) Withdraw(asset common.Address, amount *big.Int, to common.Address) (*types.Transaction, error) { + return _LendingPool.Contract.Withdraw(&_LendingPool.TransactOpts, asset, amount, to) +} diff --git a/curve/contracts/pool.go b/curve/contracts/pool.go new file mode 100644 index 0000000..fca431b --- /dev/null +++ b/curve/contracts/pool.go @@ -0,0 +1,3341 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package contracts + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription +) + +// PoolMetaData contains all meta data concerning the Pool contract. +var PoolMetaData = &bind.MetaData{ + ABI: "[{\"name\":\"TokenExchange\",\"inputs\":[{\"name\":\"buyer\",\"type\":\"address\",\"indexed\":true},{\"name\":\"sold_id\",\"type\":\"int128\",\"indexed\":false},{\"name\":\"tokens_sold\",\"type\":\"uint256\",\"indexed\":false},{\"name\":\"bought_id\",\"type\":\"int128\",\"indexed\":false},{\"name\":\"tokens_bought\",\"type\":\"uint256\",\"indexed\":false}],\"anonymous\":false,\"type\":\"event\"},{\"name\":\"TokenExchangeUnderlying\",\"inputs\":[{\"name\":\"buyer\",\"type\":\"address\",\"indexed\":true},{\"name\":\"sold_id\",\"type\":\"int128\",\"indexed\":false},{\"name\":\"tokens_sold\",\"type\":\"uint256\",\"indexed\":false},{\"name\":\"bought_id\",\"type\":\"int128\",\"indexed\":false},{\"name\":\"tokens_bought\",\"type\":\"uint256\",\"indexed\":false}],\"anonymous\":false,\"type\":\"event\"},{\"name\":\"AddLiquidity\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true},{\"name\":\"token_amounts\",\"type\":\"uint256[3]\",\"indexed\":false},{\"name\":\"fees\",\"type\":\"uint256[3]\",\"indexed\":false},{\"name\":\"invariant\",\"type\":\"uint256\",\"indexed\":false},{\"name\":\"token_supply\",\"type\":\"uint256\",\"indexed\":false}],\"anonymous\":false,\"type\":\"event\"},{\"name\":\"RemoveLiquidity\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true},{\"name\":\"token_amounts\",\"type\":\"uint256[3]\",\"indexed\":false},{\"name\":\"fees\",\"type\":\"uint256[3]\",\"indexed\":false},{\"name\":\"token_supply\",\"type\":\"uint256\",\"indexed\":false}],\"anonymous\":false,\"type\":\"event\"},{\"name\":\"RemoveLiquidityOne\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true},{\"name\":\"token_amount\",\"type\":\"uint256\",\"indexed\":false},{\"name\":\"coin_amount\",\"type\":\"uint256\",\"indexed\":false}],\"anonymous\":false,\"type\":\"event\"},{\"name\":\"RemoveLiquidityImbalance\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true},{\"name\":\"token_amounts\",\"type\":\"uint256[3]\",\"indexed\":false},{\"name\":\"fees\",\"type\":\"uint256[3]\",\"indexed\":false},{\"name\":\"invariant\",\"type\":\"uint256\",\"indexed\":false},{\"name\":\"token_supply\",\"type\":\"uint256\",\"indexed\":false}],\"anonymous\":false,\"type\":\"event\"},{\"name\":\"CommitNewAdmin\",\"inputs\":[{\"name\":\"deadline\",\"type\":\"uint256\",\"indexed\":true},{\"name\":\"admin\",\"type\":\"address\",\"indexed\":true}],\"anonymous\":false,\"type\":\"event\"},{\"name\":\"NewAdmin\",\"inputs\":[{\"name\":\"admin\",\"type\":\"address\",\"indexed\":true}],\"anonymous\":false,\"type\":\"event\"},{\"name\":\"CommitNewFee\",\"inputs\":[{\"name\":\"deadline\",\"type\":\"uint256\",\"indexed\":true},{\"name\":\"fee\",\"type\":\"uint256\",\"indexed\":false},{\"name\":\"admin_fee\",\"type\":\"uint256\",\"indexed\":false},{\"name\":\"offpeg_fee_multiplier\",\"type\":\"uint256\",\"indexed\":false}],\"anonymous\":false,\"type\":\"event\"},{\"name\":\"NewFee\",\"inputs\":[{\"name\":\"fee\",\"type\":\"uint256\",\"indexed\":false},{\"name\":\"admin_fee\",\"type\":\"uint256\",\"indexed\":false},{\"name\":\"offpeg_fee_multiplier\",\"type\":\"uint256\",\"indexed\":false}],\"anonymous\":false,\"type\":\"event\"},{\"name\":\"RampA\",\"inputs\":[{\"name\":\"old_A\",\"type\":\"uint256\",\"indexed\":false},{\"name\":\"new_A\",\"type\":\"uint256\",\"indexed\":false},{\"name\":\"initial_time\",\"type\":\"uint256\",\"indexed\":false},{\"name\":\"future_time\",\"type\":\"uint256\",\"indexed\":false}],\"anonymous\":false,\"type\":\"event\"},{\"name\":\"StopRampA\",\"inputs\":[{\"name\":\"A\",\"type\":\"uint256\",\"indexed\":false},{\"name\":\"t\",\"type\":\"uint256\",\"indexed\":false}],\"anonymous\":false,\"type\":\"event\"},{\"stateMutability\":\"nonpayable\",\"type\":\"constructor\",\"inputs\":[{\"name\":\"_coins\",\"type\":\"address[3]\"},{\"name\":\"_underlying_coins\",\"type\":\"address[3]\"},{\"name\":\"_pool_token\",\"type\":\"address\"},{\"name\":\"_A\",\"type\":\"uint256\"},{\"name\":\"_fee\",\"type\":\"uint256\"},{\"name\":\"_admin_fee\",\"type\":\"uint256\"},{\"name\":\"_offpeg_fee_multiplier\",\"type\":\"uint256\"}],\"outputs\":[]},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"A\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":10374},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"A_precise\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":10336},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"dynamic_fee\",\"inputs\":[{\"name\":\"i\",\"type\":\"int128\"},{\"name\":\"j\",\"type\":\"int128\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":21857},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"balances\",\"inputs\":[{\"name\":\"i\",\"type\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":7230},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"get_virtual_price\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":2701683},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"calc_token_amount\",\"inputs\":[{\"name\":\"_amounts\",\"type\":\"uint256[3]\"},{\"name\":\"is_deposit\",\"type\":\"bool\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":5367778},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"add_liquidity\",\"inputs\":[{\"name\":\"_amounts\",\"type\":\"uint256[3]\"},{\"name\":\"_min_mint_amount\",\"type\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}]},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"add_liquidity\",\"inputs\":[{\"name\":\"_amounts\",\"type\":\"uint256[3]\"},{\"name\":\"_min_mint_amount\",\"type\":\"uint256\"},{\"name\":\"_use_underlying\",\"type\":\"bool\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}]},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"get_dy\",\"inputs\":[{\"name\":\"i\",\"type\":\"int128\"},{\"name\":\"j\",\"type\":\"int128\"},{\"name\":\"dx\",\"type\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":6288606},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"get_dy_underlying\",\"inputs\":[{\"name\":\"i\",\"type\":\"int128\"},{\"name\":\"j\",\"type\":\"int128\"},{\"name\":\"dx\",\"type\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":6288636},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"exchange\",\"inputs\":[{\"name\":\"i\",\"type\":\"int128\"},{\"name\":\"j\",\"type\":\"int128\"},{\"name\":\"dx\",\"type\":\"uint256\"},{\"name\":\"min_dy\",\"type\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":6464164},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"exchange_underlying\",\"inputs\":[{\"name\":\"i\",\"type\":\"int128\"},{\"name\":\"j\",\"type\":\"int128\"},{\"name\":\"dx\",\"type\":\"uint256\"},{\"name\":\"min_dy\",\"type\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":6483014},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"remove_liquidity\",\"inputs\":[{\"name\":\"_amount\",\"type\":\"uint256\"},{\"name\":\"_min_amounts\",\"type\":\"uint256[3]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[3]\"}]},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"remove_liquidity\",\"inputs\":[{\"name\":\"_amount\",\"type\":\"uint256\"},{\"name\":\"_min_amounts\",\"type\":\"uint256[3]\"},{\"name\":\"_use_underlying\",\"type\":\"bool\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[3]\"}]},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"remove_liquidity_imbalance\",\"inputs\":[{\"name\":\"_amounts\",\"type\":\"uint256[3]\"},{\"name\":\"_max_burn_amount\",\"type\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}]},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"remove_liquidity_imbalance\",\"inputs\":[{\"name\":\"_amounts\",\"type\":\"uint256[3]\"},{\"name\":\"_max_burn_amount\",\"type\":\"uint256\"},{\"name\":\"_use_underlying\",\"type\":\"bool\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}]},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"calc_withdraw_one_coin\",\"inputs\":[{\"name\":\"_token_amount\",\"type\":\"uint256\"},{\"name\":\"i\",\"type\":\"int128\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":4490262},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"remove_liquidity_one_coin\",\"inputs\":[{\"name\":\"_token_amount\",\"type\":\"uint256\"},{\"name\":\"i\",\"type\":\"int128\"},{\"name\":\"_min_amount\",\"type\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}]},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"remove_liquidity_one_coin\",\"inputs\":[{\"name\":\"_token_amount\",\"type\":\"uint256\"},{\"name\":\"i\",\"type\":\"int128\"},{\"name\":\"_min_amount\",\"type\":\"uint256\"},{\"name\":\"_use_underlying\",\"type\":\"bool\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}]},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"ramp_A\",\"inputs\":[{\"name\":\"_future_A\",\"type\":\"uint256\"},{\"name\":\"_future_time\",\"type\":\"uint256\"}],\"outputs\":[],\"gas\":159459},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"stop_ramp_A\",\"inputs\":[],\"outputs\":[],\"gas\":154920},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"commit_new_fee\",\"inputs\":[{\"name\":\"new_fee\",\"type\":\"uint256\"},{\"name\":\"new_admin_fee\",\"type\":\"uint256\"},{\"name\":\"new_offpeg_fee_multiplier\",\"type\":\"uint256\"}],\"outputs\":[],\"gas\":148809},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"apply_new_fee\",\"inputs\":[],\"outputs\":[],\"gas\":141271},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"revert_new_parameters\",\"inputs\":[],\"outputs\":[],\"gas\":23012},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"commit_transfer_ownership\",\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\"}],\"outputs\":[],\"gas\":77050},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"apply_transfer_ownership\",\"inputs\":[],\"outputs\":[],\"gas\":65727},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"revert_transfer_ownership\",\"inputs\":[],\"outputs\":[],\"gas\":23102},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"withdraw_admin_fees\",\"inputs\":[],\"outputs\":[],\"gas\":90405},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"donate_admin_fees\",\"inputs\":[],\"outputs\":[],\"gas\":63231},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"kill_me\",\"inputs\":[],\"outputs\":[],\"gas\":40385},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"unkill_me\",\"inputs\":[],\"outputs\":[],\"gas\":23222},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"set_aave_referral\",\"inputs\":[{\"name\":\"referral_code\",\"type\":\"uint256\"}],\"outputs\":[],\"gas\":38352},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"set_reward_receiver\",\"inputs\":[{\"name\":\"_reward_receiver\",\"type\":\"address\"}],\"outputs\":[],\"gas\":38385},{\"stateMutability\":\"nonpayable\",\"type\":\"function\",\"name\":\"set_admin_fee_receiver\",\"inputs\":[{\"name\":\"_admin_fee_receiver\",\"type\":\"address\"}],\"outputs\":[],\"gas\":38415},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"coins\",\"inputs\":[{\"name\":\"arg0\",\"type\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"gas\":3333},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"underlying_coins\",\"inputs\":[{\"name\":\"arg0\",\"type\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"gas\":3363},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"admin_balances\",\"inputs\":[{\"name\":\"arg0\",\"type\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":3393},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"fee\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":3378},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"offpeg_fee_multiplier\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":3408},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"admin_fee\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":3438},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"gas\":3468},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"lp_token\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"gas\":3498},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"initial_A\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":3528},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"future_A\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":3558},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"initial_A_time\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":3588},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"future_A_time\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":3618},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"admin_actions_deadline\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":3648},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"transfer_ownership_deadline\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":3678},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"future_fee\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":3708},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"future_admin_fee\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":3738},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"future_offpeg_fee_multiplier\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"gas\":3768},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"future_owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"gas\":3798},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"reward_receiver\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"gas\":3828},{\"stateMutability\":\"view\",\"type\":\"function\",\"name\":\"admin_fee_receiver\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"gas\":3858}]", +} + +// PoolABI is the input ABI used to generate the binding from. +// Deprecated: Use PoolMetaData.ABI instead. +var PoolABI = PoolMetaData.ABI + +// Pool is an auto generated Go binding around an Ethereum contract. +type Pool struct { + PoolCaller // Read-only binding to the contract + PoolTransactor // Write-only binding to the contract + PoolFilterer // Log filterer for contract events +} + +// PoolCaller is an auto generated read-only Go binding around an Ethereum contract. +type PoolCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PoolTransactor is an auto generated write-only Go binding around an Ethereum contract. +type PoolTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PoolFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type PoolFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PoolSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type PoolSession struct { + Contract *Pool // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// PoolCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type PoolCallerSession struct { + Contract *PoolCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// PoolTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type PoolTransactorSession struct { + Contract *PoolTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// PoolRaw is an auto generated low-level Go binding around an Ethereum contract. +type PoolRaw struct { + Contract *Pool // Generic contract binding to access the raw methods on +} + +// PoolCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type PoolCallerRaw struct { + Contract *PoolCaller // Generic read-only contract binding to access the raw methods on +} + +// PoolTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type PoolTransactorRaw struct { + Contract *PoolTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewPool creates a new instance of Pool, bound to a specific deployed contract. +func NewPool(address common.Address, backend bind.ContractBackend) (*Pool, error) { + contract, err := bindPool(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Pool{PoolCaller: PoolCaller{contract: contract}, PoolTransactor: PoolTransactor{contract: contract}, PoolFilterer: PoolFilterer{contract: contract}}, nil +} + +// NewPoolCaller creates a new read-only instance of Pool, bound to a specific deployed contract. +func NewPoolCaller(address common.Address, caller bind.ContractCaller) (*PoolCaller, error) { + contract, err := bindPool(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &PoolCaller{contract: contract}, nil +} + +// NewPoolTransactor creates a new write-only instance of Pool, bound to a specific deployed contract. +func NewPoolTransactor(address common.Address, transactor bind.ContractTransactor) (*PoolTransactor, error) { + contract, err := bindPool(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &PoolTransactor{contract: contract}, nil +} + +// NewPoolFilterer creates a new log filterer instance of Pool, bound to a specific deployed contract. +func NewPoolFilterer(address common.Address, filterer bind.ContractFilterer) (*PoolFilterer, error) { + contract, err := bindPool(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &PoolFilterer{contract: contract}, nil +} + +// bindPool binds a generic wrapper to an already deployed contract. +func bindPool(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader(PoolABI)) + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Pool *PoolRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Pool.Contract.PoolCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Pool *PoolRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Pool.Contract.PoolTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Pool *PoolRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Pool.Contract.PoolTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Pool *PoolCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Pool.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Pool *PoolTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Pool.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Pool *PoolTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Pool.Contract.contract.Transact(opts, method, params...) +} + +// A is a free data retrieval call binding the contract method 0xf446c1d0. +// +// Solidity: function A() view returns(uint256) +func (_Pool *PoolCaller) A(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "A") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// A is a free data retrieval call binding the contract method 0xf446c1d0. +// +// Solidity: function A() view returns(uint256) +func (_Pool *PoolSession) A() (*big.Int, error) { + return _Pool.Contract.A(&_Pool.CallOpts) +} + +// A is a free data retrieval call binding the contract method 0xf446c1d0. +// +// Solidity: function A() view returns(uint256) +func (_Pool *PoolCallerSession) A() (*big.Int, error) { + return _Pool.Contract.A(&_Pool.CallOpts) +} + +// APrecise is a free data retrieval call binding the contract method 0x76a2f0f0. +// +// Solidity: function A_precise() view returns(uint256) +func (_Pool *PoolCaller) APrecise(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "A_precise") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// APrecise is a free data retrieval call binding the contract method 0x76a2f0f0. +// +// Solidity: function A_precise() view returns(uint256) +func (_Pool *PoolSession) APrecise() (*big.Int, error) { + return _Pool.Contract.APrecise(&_Pool.CallOpts) +} + +// APrecise is a free data retrieval call binding the contract method 0x76a2f0f0. +// +// Solidity: function A_precise() view returns(uint256) +func (_Pool *PoolCallerSession) APrecise() (*big.Int, error) { + return _Pool.Contract.APrecise(&_Pool.CallOpts) +} + +// AdminActionsDeadline is a free data retrieval call binding the contract method 0x405e28f8. +// +// Solidity: function admin_actions_deadline() view returns(uint256) +func (_Pool *PoolCaller) AdminActionsDeadline(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "admin_actions_deadline") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// AdminActionsDeadline is a free data retrieval call binding the contract method 0x405e28f8. +// +// Solidity: function admin_actions_deadline() view returns(uint256) +func (_Pool *PoolSession) AdminActionsDeadline() (*big.Int, error) { + return _Pool.Contract.AdminActionsDeadline(&_Pool.CallOpts) +} + +// AdminActionsDeadline is a free data retrieval call binding the contract method 0x405e28f8. +// +// Solidity: function admin_actions_deadline() view returns(uint256) +func (_Pool *PoolCallerSession) AdminActionsDeadline() (*big.Int, error) { + return _Pool.Contract.AdminActionsDeadline(&_Pool.CallOpts) +} + +// AdminBalances is a free data retrieval call binding the contract method 0xe2e7d264. +// +// Solidity: function admin_balances(uint256 arg0) view returns(uint256) +func (_Pool *PoolCaller) AdminBalances(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "admin_balances", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// AdminBalances is a free data retrieval call binding the contract method 0xe2e7d264. +// +// Solidity: function admin_balances(uint256 arg0) view returns(uint256) +func (_Pool *PoolSession) AdminBalances(arg0 *big.Int) (*big.Int, error) { + return _Pool.Contract.AdminBalances(&_Pool.CallOpts, arg0) +} + +// AdminBalances is a free data retrieval call binding the contract method 0xe2e7d264. +// +// Solidity: function admin_balances(uint256 arg0) view returns(uint256) +func (_Pool *PoolCallerSession) AdminBalances(arg0 *big.Int) (*big.Int, error) { + return _Pool.Contract.AdminBalances(&_Pool.CallOpts, arg0) +} + +// AdminFee is a free data retrieval call binding the contract method 0xfee3f7f9. +// +// Solidity: function admin_fee() view returns(uint256) +func (_Pool *PoolCaller) AdminFee(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "admin_fee") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// AdminFee is a free data retrieval call binding the contract method 0xfee3f7f9. +// +// Solidity: function admin_fee() view returns(uint256) +func (_Pool *PoolSession) AdminFee() (*big.Int, error) { + return _Pool.Contract.AdminFee(&_Pool.CallOpts) +} + +// AdminFee is a free data retrieval call binding the contract method 0xfee3f7f9. +// +// Solidity: function admin_fee() view returns(uint256) +func (_Pool *PoolCallerSession) AdminFee() (*big.Int, error) { + return _Pool.Contract.AdminFee(&_Pool.CallOpts) +} + +// AdminFeeReceiver is a free data retrieval call binding the contract method 0x6e42e4d2. +// +// Solidity: function admin_fee_receiver() view returns(address) +func (_Pool *PoolCaller) AdminFeeReceiver(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "admin_fee_receiver") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// AdminFeeReceiver is a free data retrieval call binding the contract method 0x6e42e4d2. +// +// Solidity: function admin_fee_receiver() view returns(address) +func (_Pool *PoolSession) AdminFeeReceiver() (common.Address, error) { + return _Pool.Contract.AdminFeeReceiver(&_Pool.CallOpts) +} + +// AdminFeeReceiver is a free data retrieval call binding the contract method 0x6e42e4d2. +// +// Solidity: function admin_fee_receiver() view returns(address) +func (_Pool *PoolCallerSession) AdminFeeReceiver() (common.Address, error) { + return _Pool.Contract.AdminFeeReceiver(&_Pool.CallOpts) +} + +// Balances is a free data retrieval call binding the contract method 0x4903b0d1. +// +// Solidity: function balances(uint256 i) view returns(uint256) +func (_Pool *PoolCaller) Balances(opts *bind.CallOpts, i *big.Int) (*big.Int, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "balances", i) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Balances is a free data retrieval call binding the contract method 0x4903b0d1. +// +// Solidity: function balances(uint256 i) view returns(uint256) +func (_Pool *PoolSession) Balances(i *big.Int) (*big.Int, error) { + return _Pool.Contract.Balances(&_Pool.CallOpts, i) +} + +// Balances is a free data retrieval call binding the contract method 0x4903b0d1. +// +// Solidity: function balances(uint256 i) view returns(uint256) +func (_Pool *PoolCallerSession) Balances(i *big.Int) (*big.Int, error) { + return _Pool.Contract.Balances(&_Pool.CallOpts, i) +} + +// CalcTokenAmount is a free data retrieval call binding the contract method 0x3883e119. +// +// Solidity: function calc_token_amount(uint256[3] _amounts, bool is_deposit) view returns(uint256) +func (_Pool *PoolCaller) CalcTokenAmount(opts *bind.CallOpts, _amounts [3]*big.Int, is_deposit bool) (*big.Int, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "calc_token_amount", _amounts, is_deposit) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// CalcTokenAmount is a free data retrieval call binding the contract method 0x3883e119. +// +// Solidity: function calc_token_amount(uint256[3] _amounts, bool is_deposit) view returns(uint256) +func (_Pool *PoolSession) CalcTokenAmount(_amounts [3]*big.Int, is_deposit bool) (*big.Int, error) { + return _Pool.Contract.CalcTokenAmount(&_Pool.CallOpts, _amounts, is_deposit) +} + +// CalcTokenAmount is a free data retrieval call binding the contract method 0x3883e119. +// +// Solidity: function calc_token_amount(uint256[3] _amounts, bool is_deposit) view returns(uint256) +func (_Pool *PoolCallerSession) CalcTokenAmount(_amounts [3]*big.Int, is_deposit bool) (*big.Int, error) { + return _Pool.Contract.CalcTokenAmount(&_Pool.CallOpts, _amounts, is_deposit) +} + +// CalcWithdrawOneCoin is a free data retrieval call binding the contract method 0xcc2b27d7. +// +// Solidity: function calc_withdraw_one_coin(uint256 _token_amount, int128 i) view returns(uint256) +func (_Pool *PoolCaller) CalcWithdrawOneCoin(opts *bind.CallOpts, _token_amount *big.Int, i *big.Int) (*big.Int, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "calc_withdraw_one_coin", _token_amount, i) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// CalcWithdrawOneCoin is a free data retrieval call binding the contract method 0xcc2b27d7. +// +// Solidity: function calc_withdraw_one_coin(uint256 _token_amount, int128 i) view returns(uint256) +func (_Pool *PoolSession) CalcWithdrawOneCoin(_token_amount *big.Int, i *big.Int) (*big.Int, error) { + return _Pool.Contract.CalcWithdrawOneCoin(&_Pool.CallOpts, _token_amount, i) +} + +// CalcWithdrawOneCoin is a free data retrieval call binding the contract method 0xcc2b27d7. +// +// Solidity: function calc_withdraw_one_coin(uint256 _token_amount, int128 i) view returns(uint256) +func (_Pool *PoolCallerSession) CalcWithdrawOneCoin(_token_amount *big.Int, i *big.Int) (*big.Int, error) { + return _Pool.Contract.CalcWithdrawOneCoin(&_Pool.CallOpts, _token_amount, i) +} + +// Coins is a free data retrieval call binding the contract method 0xc6610657. +// +// Solidity: function coins(uint256 arg0) view returns(address) +func (_Pool *PoolCaller) Coins(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "coins", arg0) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Coins is a free data retrieval call binding the contract method 0xc6610657. +// +// Solidity: function coins(uint256 arg0) view returns(address) +func (_Pool *PoolSession) Coins(arg0 *big.Int) (common.Address, error) { + return _Pool.Contract.Coins(&_Pool.CallOpts, arg0) +} + +// Coins is a free data retrieval call binding the contract method 0xc6610657. +// +// Solidity: function coins(uint256 arg0) view returns(address) +func (_Pool *PoolCallerSession) Coins(arg0 *big.Int) (common.Address, error) { + return _Pool.Contract.Coins(&_Pool.CallOpts, arg0) +} + +// DynamicFee is a free data retrieval call binding the contract method 0x76a9cd3e. +// +// Solidity: function dynamic_fee(int128 i, int128 j) view returns(uint256) +func (_Pool *PoolCaller) DynamicFee(opts *bind.CallOpts, i *big.Int, j *big.Int) (*big.Int, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "dynamic_fee", i, j) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// DynamicFee is a free data retrieval call binding the contract method 0x76a9cd3e. +// +// Solidity: function dynamic_fee(int128 i, int128 j) view returns(uint256) +func (_Pool *PoolSession) DynamicFee(i *big.Int, j *big.Int) (*big.Int, error) { + return _Pool.Contract.DynamicFee(&_Pool.CallOpts, i, j) +} + +// DynamicFee is a free data retrieval call binding the contract method 0x76a9cd3e. +// +// Solidity: function dynamic_fee(int128 i, int128 j) view returns(uint256) +func (_Pool *PoolCallerSession) DynamicFee(i *big.Int, j *big.Int) (*big.Int, error) { + return _Pool.Contract.DynamicFee(&_Pool.CallOpts, i, j) +} + +// Fee is a free data retrieval call binding the contract method 0xddca3f43. +// +// Solidity: function fee() view returns(uint256) +func (_Pool *PoolCaller) Fee(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "fee") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Fee is a free data retrieval call binding the contract method 0xddca3f43. +// +// Solidity: function fee() view returns(uint256) +func (_Pool *PoolSession) Fee() (*big.Int, error) { + return _Pool.Contract.Fee(&_Pool.CallOpts) +} + +// Fee is a free data retrieval call binding the contract method 0xddca3f43. +// +// Solidity: function fee() view returns(uint256) +func (_Pool *PoolCallerSession) Fee() (*big.Int, error) { + return _Pool.Contract.Fee(&_Pool.CallOpts) +} + +// FutureA is a free data retrieval call binding the contract method 0xb4b577ad. +// +// Solidity: function future_A() view returns(uint256) +func (_Pool *PoolCaller) FutureA(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "future_A") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// FutureA is a free data retrieval call binding the contract method 0xb4b577ad. +// +// Solidity: function future_A() view returns(uint256) +func (_Pool *PoolSession) FutureA() (*big.Int, error) { + return _Pool.Contract.FutureA(&_Pool.CallOpts) +} + +// FutureA is a free data retrieval call binding the contract method 0xb4b577ad. +// +// Solidity: function future_A() view returns(uint256) +func (_Pool *PoolCallerSession) FutureA() (*big.Int, error) { + return _Pool.Contract.FutureA(&_Pool.CallOpts) +} + +// FutureATime is a free data retrieval call binding the contract method 0x14052288. +// +// Solidity: function future_A_time() view returns(uint256) +func (_Pool *PoolCaller) FutureATime(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "future_A_time") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// FutureATime is a free data retrieval call binding the contract method 0x14052288. +// +// Solidity: function future_A_time() view returns(uint256) +func (_Pool *PoolSession) FutureATime() (*big.Int, error) { + return _Pool.Contract.FutureATime(&_Pool.CallOpts) +} + +// FutureATime is a free data retrieval call binding the contract method 0x14052288. +// +// Solidity: function future_A_time() view returns(uint256) +func (_Pool *PoolCallerSession) FutureATime() (*big.Int, error) { + return _Pool.Contract.FutureATime(&_Pool.CallOpts) +} + +// FutureAdminFee is a free data retrieval call binding the contract method 0xe3824462. +// +// Solidity: function future_admin_fee() view returns(uint256) +func (_Pool *PoolCaller) FutureAdminFee(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "future_admin_fee") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// FutureAdminFee is a free data retrieval call binding the contract method 0xe3824462. +// +// Solidity: function future_admin_fee() view returns(uint256) +func (_Pool *PoolSession) FutureAdminFee() (*big.Int, error) { + return _Pool.Contract.FutureAdminFee(&_Pool.CallOpts) +} + +// FutureAdminFee is a free data retrieval call binding the contract method 0xe3824462. +// +// Solidity: function future_admin_fee() view returns(uint256) +func (_Pool *PoolCallerSession) FutureAdminFee() (*big.Int, error) { + return _Pool.Contract.FutureAdminFee(&_Pool.CallOpts) +} + +// FutureFee is a free data retrieval call binding the contract method 0x58680d0b. +// +// Solidity: function future_fee() view returns(uint256) +func (_Pool *PoolCaller) FutureFee(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "future_fee") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// FutureFee is a free data retrieval call binding the contract method 0x58680d0b. +// +// Solidity: function future_fee() view returns(uint256) +func (_Pool *PoolSession) FutureFee() (*big.Int, error) { + return _Pool.Contract.FutureFee(&_Pool.CallOpts) +} + +// FutureFee is a free data retrieval call binding the contract method 0x58680d0b. +// +// Solidity: function future_fee() view returns(uint256) +func (_Pool *PoolCallerSession) FutureFee() (*big.Int, error) { + return _Pool.Contract.FutureFee(&_Pool.CallOpts) +} + +// FutureOffpegFeeMultiplier is a free data retrieval call binding the contract method 0x1e4c4ef8. +// +// Solidity: function future_offpeg_fee_multiplier() view returns(uint256) +func (_Pool *PoolCaller) FutureOffpegFeeMultiplier(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "future_offpeg_fee_multiplier") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// FutureOffpegFeeMultiplier is a free data retrieval call binding the contract method 0x1e4c4ef8. +// +// Solidity: function future_offpeg_fee_multiplier() view returns(uint256) +func (_Pool *PoolSession) FutureOffpegFeeMultiplier() (*big.Int, error) { + return _Pool.Contract.FutureOffpegFeeMultiplier(&_Pool.CallOpts) +} + +// FutureOffpegFeeMultiplier is a free data retrieval call binding the contract method 0x1e4c4ef8. +// +// Solidity: function future_offpeg_fee_multiplier() view returns(uint256) +func (_Pool *PoolCallerSession) FutureOffpegFeeMultiplier() (*big.Int, error) { + return _Pool.Contract.FutureOffpegFeeMultiplier(&_Pool.CallOpts) +} + +// FutureOwner is a free data retrieval call binding the contract method 0x1ec0cdc1. +// +// Solidity: function future_owner() view returns(address) +func (_Pool *PoolCaller) FutureOwner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "future_owner") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// FutureOwner is a free data retrieval call binding the contract method 0x1ec0cdc1. +// +// Solidity: function future_owner() view returns(address) +func (_Pool *PoolSession) FutureOwner() (common.Address, error) { + return _Pool.Contract.FutureOwner(&_Pool.CallOpts) +} + +// FutureOwner is a free data retrieval call binding the contract method 0x1ec0cdc1. +// +// Solidity: function future_owner() view returns(address) +func (_Pool *PoolCallerSession) FutureOwner() (common.Address, error) { + return _Pool.Contract.FutureOwner(&_Pool.CallOpts) +} + +// GetDy is a free data retrieval call binding the contract method 0x5e0d443f. +// +// Solidity: function get_dy(int128 i, int128 j, uint256 dx) view returns(uint256) +func (_Pool *PoolCaller) GetDy(opts *bind.CallOpts, i *big.Int, j *big.Int, dx *big.Int) (*big.Int, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "get_dy", i, j, dx) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetDy is a free data retrieval call binding the contract method 0x5e0d443f. +// +// Solidity: function get_dy(int128 i, int128 j, uint256 dx) view returns(uint256) +func (_Pool *PoolSession) GetDy(i *big.Int, j *big.Int, dx *big.Int) (*big.Int, error) { + return _Pool.Contract.GetDy(&_Pool.CallOpts, i, j, dx) +} + +// GetDy is a free data retrieval call binding the contract method 0x5e0d443f. +// +// Solidity: function get_dy(int128 i, int128 j, uint256 dx) view returns(uint256) +func (_Pool *PoolCallerSession) GetDy(i *big.Int, j *big.Int, dx *big.Int) (*big.Int, error) { + return _Pool.Contract.GetDy(&_Pool.CallOpts, i, j, dx) +} + +// GetDyUnderlying is a free data retrieval call binding the contract method 0x07211ef7. +// +// Solidity: function get_dy_underlying(int128 i, int128 j, uint256 dx) view returns(uint256) +func (_Pool *PoolCaller) GetDyUnderlying(opts *bind.CallOpts, i *big.Int, j *big.Int, dx *big.Int) (*big.Int, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "get_dy_underlying", i, j, dx) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetDyUnderlying is a free data retrieval call binding the contract method 0x07211ef7. +// +// Solidity: function get_dy_underlying(int128 i, int128 j, uint256 dx) view returns(uint256) +func (_Pool *PoolSession) GetDyUnderlying(i *big.Int, j *big.Int, dx *big.Int) (*big.Int, error) { + return _Pool.Contract.GetDyUnderlying(&_Pool.CallOpts, i, j, dx) +} + +// GetDyUnderlying is a free data retrieval call binding the contract method 0x07211ef7. +// +// Solidity: function get_dy_underlying(int128 i, int128 j, uint256 dx) view returns(uint256) +func (_Pool *PoolCallerSession) GetDyUnderlying(i *big.Int, j *big.Int, dx *big.Int) (*big.Int, error) { + return _Pool.Contract.GetDyUnderlying(&_Pool.CallOpts, i, j, dx) +} + +// GetVirtualPrice is a free data retrieval call binding the contract method 0xbb7b8b80. +// +// Solidity: function get_virtual_price() view returns(uint256) +func (_Pool *PoolCaller) GetVirtualPrice(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "get_virtual_price") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetVirtualPrice is a free data retrieval call binding the contract method 0xbb7b8b80. +// +// Solidity: function get_virtual_price() view returns(uint256) +func (_Pool *PoolSession) GetVirtualPrice() (*big.Int, error) { + return _Pool.Contract.GetVirtualPrice(&_Pool.CallOpts) +} + +// GetVirtualPrice is a free data retrieval call binding the contract method 0xbb7b8b80. +// +// Solidity: function get_virtual_price() view returns(uint256) +func (_Pool *PoolCallerSession) GetVirtualPrice() (*big.Int, error) { + return _Pool.Contract.GetVirtualPrice(&_Pool.CallOpts) +} + +// InitialA is a free data retrieval call binding the contract method 0x5409491a. +// +// Solidity: function initial_A() view returns(uint256) +func (_Pool *PoolCaller) InitialA(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "initial_A") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// InitialA is a free data retrieval call binding the contract method 0x5409491a. +// +// Solidity: function initial_A() view returns(uint256) +func (_Pool *PoolSession) InitialA() (*big.Int, error) { + return _Pool.Contract.InitialA(&_Pool.CallOpts) +} + +// InitialA is a free data retrieval call binding the contract method 0x5409491a. +// +// Solidity: function initial_A() view returns(uint256) +func (_Pool *PoolCallerSession) InitialA() (*big.Int, error) { + return _Pool.Contract.InitialA(&_Pool.CallOpts) +} + +// InitialATime is a free data retrieval call binding the contract method 0x2081066c. +// +// Solidity: function initial_A_time() view returns(uint256) +func (_Pool *PoolCaller) InitialATime(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "initial_A_time") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// InitialATime is a free data retrieval call binding the contract method 0x2081066c. +// +// Solidity: function initial_A_time() view returns(uint256) +func (_Pool *PoolSession) InitialATime() (*big.Int, error) { + return _Pool.Contract.InitialATime(&_Pool.CallOpts) +} + +// InitialATime is a free data retrieval call binding the contract method 0x2081066c. +// +// Solidity: function initial_A_time() view returns(uint256) +func (_Pool *PoolCallerSession) InitialATime() (*big.Int, error) { + return _Pool.Contract.InitialATime(&_Pool.CallOpts) +} + +// LpToken is a free data retrieval call binding the contract method 0x82c63066. +// +// Solidity: function lp_token() view returns(address) +func (_Pool *PoolCaller) LpToken(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "lp_token") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// LpToken is a free data retrieval call binding the contract method 0x82c63066. +// +// Solidity: function lp_token() view returns(address) +func (_Pool *PoolSession) LpToken() (common.Address, error) { + return _Pool.Contract.LpToken(&_Pool.CallOpts) +} + +// LpToken is a free data retrieval call binding the contract method 0x82c63066. +// +// Solidity: function lp_token() view returns(address) +func (_Pool *PoolCallerSession) LpToken() (common.Address, error) { + return _Pool.Contract.LpToken(&_Pool.CallOpts) +} + +// OffpegFeeMultiplier is a free data retrieval call binding the contract method 0x8edfdd5f. +// +// Solidity: function offpeg_fee_multiplier() view returns(uint256) +func (_Pool *PoolCaller) OffpegFeeMultiplier(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "offpeg_fee_multiplier") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// OffpegFeeMultiplier is a free data retrieval call binding the contract method 0x8edfdd5f. +// +// Solidity: function offpeg_fee_multiplier() view returns(uint256) +func (_Pool *PoolSession) OffpegFeeMultiplier() (*big.Int, error) { + return _Pool.Contract.OffpegFeeMultiplier(&_Pool.CallOpts) +} + +// OffpegFeeMultiplier is a free data retrieval call binding the contract method 0x8edfdd5f. +// +// Solidity: function offpeg_fee_multiplier() view returns(uint256) +func (_Pool *PoolCallerSession) OffpegFeeMultiplier() (*big.Int, error) { + return _Pool.Contract.OffpegFeeMultiplier(&_Pool.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Pool *PoolCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "owner") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Pool *PoolSession) Owner() (common.Address, error) { + return _Pool.Contract.Owner(&_Pool.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Pool *PoolCallerSession) Owner() (common.Address, error) { + return _Pool.Contract.Owner(&_Pool.CallOpts) +} + +// RewardReceiver is a free data retrieval call binding the contract method 0xb618ba62. +// +// Solidity: function reward_receiver() view returns(address) +func (_Pool *PoolCaller) RewardReceiver(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "reward_receiver") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// RewardReceiver is a free data retrieval call binding the contract method 0xb618ba62. +// +// Solidity: function reward_receiver() view returns(address) +func (_Pool *PoolSession) RewardReceiver() (common.Address, error) { + return _Pool.Contract.RewardReceiver(&_Pool.CallOpts) +} + +// RewardReceiver is a free data retrieval call binding the contract method 0xb618ba62. +// +// Solidity: function reward_receiver() view returns(address) +func (_Pool *PoolCallerSession) RewardReceiver() (common.Address, error) { + return _Pool.Contract.RewardReceiver(&_Pool.CallOpts) +} + +// TransferOwnershipDeadline is a free data retrieval call binding the contract method 0xe0a0b586. +// +// Solidity: function transfer_ownership_deadline() view returns(uint256) +func (_Pool *PoolCaller) TransferOwnershipDeadline(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "transfer_ownership_deadline") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// TransferOwnershipDeadline is a free data retrieval call binding the contract method 0xe0a0b586. +// +// Solidity: function transfer_ownership_deadline() view returns(uint256) +func (_Pool *PoolSession) TransferOwnershipDeadline() (*big.Int, error) { + return _Pool.Contract.TransferOwnershipDeadline(&_Pool.CallOpts) +} + +// TransferOwnershipDeadline is a free data retrieval call binding the contract method 0xe0a0b586. +// +// Solidity: function transfer_ownership_deadline() view returns(uint256) +func (_Pool *PoolCallerSession) TransferOwnershipDeadline() (*big.Int, error) { + return _Pool.Contract.TransferOwnershipDeadline(&_Pool.CallOpts) +} + +// UnderlyingCoins is a free data retrieval call binding the contract method 0xb9947eb0. +// +// Solidity: function underlying_coins(uint256 arg0) view returns(address) +func (_Pool *PoolCaller) UnderlyingCoins(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error) { + var out []interface{} + err := _Pool.contract.Call(opts, &out, "underlying_coins", arg0) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// UnderlyingCoins is a free data retrieval call binding the contract method 0xb9947eb0. +// +// Solidity: function underlying_coins(uint256 arg0) view returns(address) +func (_Pool *PoolSession) UnderlyingCoins(arg0 *big.Int) (common.Address, error) { + return _Pool.Contract.UnderlyingCoins(&_Pool.CallOpts, arg0) +} + +// UnderlyingCoins is a free data retrieval call binding the contract method 0xb9947eb0. +// +// Solidity: function underlying_coins(uint256 arg0) view returns(address) +func (_Pool *PoolCallerSession) UnderlyingCoins(arg0 *big.Int) (common.Address, error) { + return _Pool.Contract.UnderlyingCoins(&_Pool.CallOpts, arg0) +} + +// AddLiquidity is a paid mutator transaction binding the contract method 0x4515cef3. +// +// Solidity: function add_liquidity(uint256[3] _amounts, uint256 _min_mint_amount) returns(uint256) +func (_Pool *PoolTransactor) AddLiquidity(opts *bind.TransactOpts, _amounts [3]*big.Int, _min_mint_amount *big.Int) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "add_liquidity", _amounts, _min_mint_amount) +} + +// AddLiquidity is a paid mutator transaction binding the contract method 0x4515cef3. +// +// Solidity: function add_liquidity(uint256[3] _amounts, uint256 _min_mint_amount) returns(uint256) +func (_Pool *PoolSession) AddLiquidity(_amounts [3]*big.Int, _min_mint_amount *big.Int) (*types.Transaction, error) { + return _Pool.Contract.AddLiquidity(&_Pool.TransactOpts, _amounts, _min_mint_amount) +} + +// AddLiquidity is a paid mutator transaction binding the contract method 0x4515cef3. +// +// Solidity: function add_liquidity(uint256[3] _amounts, uint256 _min_mint_amount) returns(uint256) +func (_Pool *PoolTransactorSession) AddLiquidity(_amounts [3]*big.Int, _min_mint_amount *big.Int) (*types.Transaction, error) { + return _Pool.Contract.AddLiquidity(&_Pool.TransactOpts, _amounts, _min_mint_amount) +} + +// AddLiquidity0 is a paid mutator transaction binding the contract method 0x2b6e993a. +// +// Solidity: function add_liquidity(uint256[3] _amounts, uint256 _min_mint_amount, bool _use_underlying) returns(uint256) +func (_Pool *PoolTransactor) AddLiquidity0(opts *bind.TransactOpts, _amounts [3]*big.Int, _min_mint_amount *big.Int, _use_underlying bool) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "add_liquidity0", _amounts, _min_mint_amount, _use_underlying) +} + +// AddLiquidity0 is a paid mutator transaction binding the contract method 0x2b6e993a. +// +// Solidity: function add_liquidity(uint256[3] _amounts, uint256 _min_mint_amount, bool _use_underlying) returns(uint256) +func (_Pool *PoolSession) AddLiquidity0(_amounts [3]*big.Int, _min_mint_amount *big.Int, _use_underlying bool) (*types.Transaction, error) { + return _Pool.Contract.AddLiquidity0(&_Pool.TransactOpts, _amounts, _min_mint_amount, _use_underlying) +} + +// AddLiquidity0 is a paid mutator transaction binding the contract method 0x2b6e993a. +// +// Solidity: function add_liquidity(uint256[3] _amounts, uint256 _min_mint_amount, bool _use_underlying) returns(uint256) +func (_Pool *PoolTransactorSession) AddLiquidity0(_amounts [3]*big.Int, _min_mint_amount *big.Int, _use_underlying bool) (*types.Transaction, error) { + return _Pool.Contract.AddLiquidity0(&_Pool.TransactOpts, _amounts, _min_mint_amount, _use_underlying) +} + +// ApplyNewFee is a paid mutator transaction binding the contract method 0x4f12fe97. +// +// Solidity: function apply_new_fee() returns() +func (_Pool *PoolTransactor) ApplyNewFee(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "apply_new_fee") +} + +// ApplyNewFee is a paid mutator transaction binding the contract method 0x4f12fe97. +// +// Solidity: function apply_new_fee() returns() +func (_Pool *PoolSession) ApplyNewFee() (*types.Transaction, error) { + return _Pool.Contract.ApplyNewFee(&_Pool.TransactOpts) +} + +// ApplyNewFee is a paid mutator transaction binding the contract method 0x4f12fe97. +// +// Solidity: function apply_new_fee() returns() +func (_Pool *PoolTransactorSession) ApplyNewFee() (*types.Transaction, error) { + return _Pool.Contract.ApplyNewFee(&_Pool.TransactOpts) +} + +// ApplyTransferOwnership is a paid mutator transaction binding the contract method 0x6a1c05ae. +// +// Solidity: function apply_transfer_ownership() returns() +func (_Pool *PoolTransactor) ApplyTransferOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "apply_transfer_ownership") +} + +// ApplyTransferOwnership is a paid mutator transaction binding the contract method 0x6a1c05ae. +// +// Solidity: function apply_transfer_ownership() returns() +func (_Pool *PoolSession) ApplyTransferOwnership() (*types.Transaction, error) { + return _Pool.Contract.ApplyTransferOwnership(&_Pool.TransactOpts) +} + +// ApplyTransferOwnership is a paid mutator transaction binding the contract method 0x6a1c05ae. +// +// Solidity: function apply_transfer_ownership() returns() +func (_Pool *PoolTransactorSession) ApplyTransferOwnership() (*types.Transaction, error) { + return _Pool.Contract.ApplyTransferOwnership(&_Pool.TransactOpts) +} + +// CommitNewFee is a paid mutator transaction binding the contract method 0x0746dd5a. +// +// Solidity: function commit_new_fee(uint256 new_fee, uint256 new_admin_fee, uint256 new_offpeg_fee_multiplier) returns() +func (_Pool *PoolTransactor) CommitNewFee(opts *bind.TransactOpts, new_fee *big.Int, new_admin_fee *big.Int, new_offpeg_fee_multiplier *big.Int) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "commit_new_fee", new_fee, new_admin_fee, new_offpeg_fee_multiplier) +} + +// CommitNewFee is a paid mutator transaction binding the contract method 0x0746dd5a. +// +// Solidity: function commit_new_fee(uint256 new_fee, uint256 new_admin_fee, uint256 new_offpeg_fee_multiplier) returns() +func (_Pool *PoolSession) CommitNewFee(new_fee *big.Int, new_admin_fee *big.Int, new_offpeg_fee_multiplier *big.Int) (*types.Transaction, error) { + return _Pool.Contract.CommitNewFee(&_Pool.TransactOpts, new_fee, new_admin_fee, new_offpeg_fee_multiplier) +} + +// CommitNewFee is a paid mutator transaction binding the contract method 0x0746dd5a. +// +// Solidity: function commit_new_fee(uint256 new_fee, uint256 new_admin_fee, uint256 new_offpeg_fee_multiplier) returns() +func (_Pool *PoolTransactorSession) CommitNewFee(new_fee *big.Int, new_admin_fee *big.Int, new_offpeg_fee_multiplier *big.Int) (*types.Transaction, error) { + return _Pool.Contract.CommitNewFee(&_Pool.TransactOpts, new_fee, new_admin_fee, new_offpeg_fee_multiplier) +} + +// CommitTransferOwnership is a paid mutator transaction binding the contract method 0x6b441a40. +// +// Solidity: function commit_transfer_ownership(address _owner) returns() +func (_Pool *PoolTransactor) CommitTransferOwnership(opts *bind.TransactOpts, _owner common.Address) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "commit_transfer_ownership", _owner) +} + +// CommitTransferOwnership is a paid mutator transaction binding the contract method 0x6b441a40. +// +// Solidity: function commit_transfer_ownership(address _owner) returns() +func (_Pool *PoolSession) CommitTransferOwnership(_owner common.Address) (*types.Transaction, error) { + return _Pool.Contract.CommitTransferOwnership(&_Pool.TransactOpts, _owner) +} + +// CommitTransferOwnership is a paid mutator transaction binding the contract method 0x6b441a40. +// +// Solidity: function commit_transfer_ownership(address _owner) returns() +func (_Pool *PoolTransactorSession) CommitTransferOwnership(_owner common.Address) (*types.Transaction, error) { + return _Pool.Contract.CommitTransferOwnership(&_Pool.TransactOpts, _owner) +} + +// DonateAdminFees is a paid mutator transaction binding the contract method 0x524c3901. +// +// Solidity: function donate_admin_fees() returns() +func (_Pool *PoolTransactor) DonateAdminFees(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "donate_admin_fees") +} + +// DonateAdminFees is a paid mutator transaction binding the contract method 0x524c3901. +// +// Solidity: function donate_admin_fees() returns() +func (_Pool *PoolSession) DonateAdminFees() (*types.Transaction, error) { + return _Pool.Contract.DonateAdminFees(&_Pool.TransactOpts) +} + +// DonateAdminFees is a paid mutator transaction binding the contract method 0x524c3901. +// +// Solidity: function donate_admin_fees() returns() +func (_Pool *PoolTransactorSession) DonateAdminFees() (*types.Transaction, error) { + return _Pool.Contract.DonateAdminFees(&_Pool.TransactOpts) +} + +// Exchange is a paid mutator transaction binding the contract method 0x3df02124. +// +// Solidity: function exchange(int128 i, int128 j, uint256 dx, uint256 min_dy) returns(uint256) +func (_Pool *PoolTransactor) Exchange(opts *bind.TransactOpts, i *big.Int, j *big.Int, dx *big.Int, min_dy *big.Int) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "exchange", i, j, dx, min_dy) +} + +// Exchange is a paid mutator transaction binding the contract method 0x3df02124. +// +// Solidity: function exchange(int128 i, int128 j, uint256 dx, uint256 min_dy) returns(uint256) +func (_Pool *PoolSession) Exchange(i *big.Int, j *big.Int, dx *big.Int, min_dy *big.Int) (*types.Transaction, error) { + return _Pool.Contract.Exchange(&_Pool.TransactOpts, i, j, dx, min_dy) +} + +// Exchange is a paid mutator transaction binding the contract method 0x3df02124. +// +// Solidity: function exchange(int128 i, int128 j, uint256 dx, uint256 min_dy) returns(uint256) +func (_Pool *PoolTransactorSession) Exchange(i *big.Int, j *big.Int, dx *big.Int, min_dy *big.Int) (*types.Transaction, error) { + return _Pool.Contract.Exchange(&_Pool.TransactOpts, i, j, dx, min_dy) +} + +// ExchangeUnderlying is a paid mutator transaction binding the contract method 0xa6417ed6. +// +// Solidity: function exchange_underlying(int128 i, int128 j, uint256 dx, uint256 min_dy) returns(uint256) +func (_Pool *PoolTransactor) ExchangeUnderlying(opts *bind.TransactOpts, i *big.Int, j *big.Int, dx *big.Int, min_dy *big.Int) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "exchange_underlying", i, j, dx, min_dy) +} + +// ExchangeUnderlying is a paid mutator transaction binding the contract method 0xa6417ed6. +// +// Solidity: function exchange_underlying(int128 i, int128 j, uint256 dx, uint256 min_dy) returns(uint256) +func (_Pool *PoolSession) ExchangeUnderlying(i *big.Int, j *big.Int, dx *big.Int, min_dy *big.Int) (*types.Transaction, error) { + return _Pool.Contract.ExchangeUnderlying(&_Pool.TransactOpts, i, j, dx, min_dy) +} + +// ExchangeUnderlying is a paid mutator transaction binding the contract method 0xa6417ed6. +// +// Solidity: function exchange_underlying(int128 i, int128 j, uint256 dx, uint256 min_dy) returns(uint256) +func (_Pool *PoolTransactorSession) ExchangeUnderlying(i *big.Int, j *big.Int, dx *big.Int, min_dy *big.Int) (*types.Transaction, error) { + return _Pool.Contract.ExchangeUnderlying(&_Pool.TransactOpts, i, j, dx, min_dy) +} + +// KillMe is a paid mutator transaction binding the contract method 0xe3698853. +// +// Solidity: function kill_me() returns() +func (_Pool *PoolTransactor) KillMe(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "kill_me") +} + +// KillMe is a paid mutator transaction binding the contract method 0xe3698853. +// +// Solidity: function kill_me() returns() +func (_Pool *PoolSession) KillMe() (*types.Transaction, error) { + return _Pool.Contract.KillMe(&_Pool.TransactOpts) +} + +// KillMe is a paid mutator transaction binding the contract method 0xe3698853. +// +// Solidity: function kill_me() returns() +func (_Pool *PoolTransactorSession) KillMe() (*types.Transaction, error) { + return _Pool.Contract.KillMe(&_Pool.TransactOpts) +} + +// RampA is a paid mutator transaction binding the contract method 0x3c157e64. +// +// Solidity: function ramp_A(uint256 _future_A, uint256 _future_time) returns() +func (_Pool *PoolTransactor) RampA(opts *bind.TransactOpts, _future_A *big.Int, _future_time *big.Int) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "ramp_A", _future_A, _future_time) +} + +// RampA is a paid mutator transaction binding the contract method 0x3c157e64. +// +// Solidity: function ramp_A(uint256 _future_A, uint256 _future_time) returns() +func (_Pool *PoolSession) RampA(_future_A *big.Int, _future_time *big.Int) (*types.Transaction, error) { + return _Pool.Contract.RampA(&_Pool.TransactOpts, _future_A, _future_time) +} + +// RampA is a paid mutator transaction binding the contract method 0x3c157e64. +// +// Solidity: function ramp_A(uint256 _future_A, uint256 _future_time) returns() +func (_Pool *PoolTransactorSession) RampA(_future_A *big.Int, _future_time *big.Int) (*types.Transaction, error) { + return _Pool.Contract.RampA(&_Pool.TransactOpts, _future_A, _future_time) +} + +// RemoveLiquidity is a paid mutator transaction binding the contract method 0xecb586a5. +// +// Solidity: function remove_liquidity(uint256 _amount, uint256[3] _min_amounts) returns(uint256[3]) +func (_Pool *PoolTransactor) RemoveLiquidity(opts *bind.TransactOpts, _amount *big.Int, _min_amounts [3]*big.Int) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "remove_liquidity", _amount, _min_amounts) +} + +// RemoveLiquidity is a paid mutator transaction binding the contract method 0xecb586a5. +// +// Solidity: function remove_liquidity(uint256 _amount, uint256[3] _min_amounts) returns(uint256[3]) +func (_Pool *PoolSession) RemoveLiquidity(_amount *big.Int, _min_amounts [3]*big.Int) (*types.Transaction, error) { + return _Pool.Contract.RemoveLiquidity(&_Pool.TransactOpts, _amount, _min_amounts) +} + +// RemoveLiquidity is a paid mutator transaction binding the contract method 0xecb586a5. +// +// Solidity: function remove_liquidity(uint256 _amount, uint256[3] _min_amounts) returns(uint256[3]) +func (_Pool *PoolTransactorSession) RemoveLiquidity(_amount *big.Int, _min_amounts [3]*big.Int) (*types.Transaction, error) { + return _Pool.Contract.RemoveLiquidity(&_Pool.TransactOpts, _amount, _min_amounts) +} + +// RemoveLiquidity0 is a paid mutator transaction binding the contract method 0xfce64736. +// +// Solidity: function remove_liquidity(uint256 _amount, uint256[3] _min_amounts, bool _use_underlying) returns(uint256[3]) +func (_Pool *PoolTransactor) RemoveLiquidity0(opts *bind.TransactOpts, _amount *big.Int, _min_amounts [3]*big.Int, _use_underlying bool) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "remove_liquidity0", _amount, _min_amounts, _use_underlying) +} + +// RemoveLiquidity0 is a paid mutator transaction binding the contract method 0xfce64736. +// +// Solidity: function remove_liquidity(uint256 _amount, uint256[3] _min_amounts, bool _use_underlying) returns(uint256[3]) +func (_Pool *PoolSession) RemoveLiquidity0(_amount *big.Int, _min_amounts [3]*big.Int, _use_underlying bool) (*types.Transaction, error) { + return _Pool.Contract.RemoveLiquidity0(&_Pool.TransactOpts, _amount, _min_amounts, _use_underlying) +} + +// RemoveLiquidity0 is a paid mutator transaction binding the contract method 0xfce64736. +// +// Solidity: function remove_liquidity(uint256 _amount, uint256[3] _min_amounts, bool _use_underlying) returns(uint256[3]) +func (_Pool *PoolTransactorSession) RemoveLiquidity0(_amount *big.Int, _min_amounts [3]*big.Int, _use_underlying bool) (*types.Transaction, error) { + return _Pool.Contract.RemoveLiquidity0(&_Pool.TransactOpts, _amount, _min_amounts, _use_underlying) +} + +// RemoveLiquidityImbalance is a paid mutator transaction binding the contract method 0x9fdaea0c. +// +// Solidity: function remove_liquidity_imbalance(uint256[3] _amounts, uint256 _max_burn_amount) returns(uint256) +func (_Pool *PoolTransactor) RemoveLiquidityImbalance(opts *bind.TransactOpts, _amounts [3]*big.Int, _max_burn_amount *big.Int) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "remove_liquidity_imbalance", _amounts, _max_burn_amount) +} + +// RemoveLiquidityImbalance is a paid mutator transaction binding the contract method 0x9fdaea0c. +// +// Solidity: function remove_liquidity_imbalance(uint256[3] _amounts, uint256 _max_burn_amount) returns(uint256) +func (_Pool *PoolSession) RemoveLiquidityImbalance(_amounts [3]*big.Int, _max_burn_amount *big.Int) (*types.Transaction, error) { + return _Pool.Contract.RemoveLiquidityImbalance(&_Pool.TransactOpts, _amounts, _max_burn_amount) +} + +// RemoveLiquidityImbalance is a paid mutator transaction binding the contract method 0x9fdaea0c. +// +// Solidity: function remove_liquidity_imbalance(uint256[3] _amounts, uint256 _max_burn_amount) returns(uint256) +func (_Pool *PoolTransactorSession) RemoveLiquidityImbalance(_amounts [3]*big.Int, _max_burn_amount *big.Int) (*types.Transaction, error) { + return _Pool.Contract.RemoveLiquidityImbalance(&_Pool.TransactOpts, _amounts, _max_burn_amount) +} + +// RemoveLiquidityImbalance0 is a paid mutator transaction binding the contract method 0x5b8369f5. +// +// Solidity: function remove_liquidity_imbalance(uint256[3] _amounts, uint256 _max_burn_amount, bool _use_underlying) returns(uint256) +func (_Pool *PoolTransactor) RemoveLiquidityImbalance0(opts *bind.TransactOpts, _amounts [3]*big.Int, _max_burn_amount *big.Int, _use_underlying bool) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "remove_liquidity_imbalance0", _amounts, _max_burn_amount, _use_underlying) +} + +// RemoveLiquidityImbalance0 is a paid mutator transaction binding the contract method 0x5b8369f5. +// +// Solidity: function remove_liquidity_imbalance(uint256[3] _amounts, uint256 _max_burn_amount, bool _use_underlying) returns(uint256) +func (_Pool *PoolSession) RemoveLiquidityImbalance0(_amounts [3]*big.Int, _max_burn_amount *big.Int, _use_underlying bool) (*types.Transaction, error) { + return _Pool.Contract.RemoveLiquidityImbalance0(&_Pool.TransactOpts, _amounts, _max_burn_amount, _use_underlying) +} + +// RemoveLiquidityImbalance0 is a paid mutator transaction binding the contract method 0x5b8369f5. +// +// Solidity: function remove_liquidity_imbalance(uint256[3] _amounts, uint256 _max_burn_amount, bool _use_underlying) returns(uint256) +func (_Pool *PoolTransactorSession) RemoveLiquidityImbalance0(_amounts [3]*big.Int, _max_burn_amount *big.Int, _use_underlying bool) (*types.Transaction, error) { + return _Pool.Contract.RemoveLiquidityImbalance0(&_Pool.TransactOpts, _amounts, _max_burn_amount, _use_underlying) +} + +// RemoveLiquidityOneCoin is a paid mutator transaction binding the contract method 0x1a4d01d2. +// +// Solidity: function remove_liquidity_one_coin(uint256 _token_amount, int128 i, uint256 _min_amount) returns(uint256) +func (_Pool *PoolTransactor) RemoveLiquidityOneCoin(opts *bind.TransactOpts, _token_amount *big.Int, i *big.Int, _min_amount *big.Int) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "remove_liquidity_one_coin", _token_amount, i, _min_amount) +} + +// RemoveLiquidityOneCoin is a paid mutator transaction binding the contract method 0x1a4d01d2. +// +// Solidity: function remove_liquidity_one_coin(uint256 _token_amount, int128 i, uint256 _min_amount) returns(uint256) +func (_Pool *PoolSession) RemoveLiquidityOneCoin(_token_amount *big.Int, i *big.Int, _min_amount *big.Int) (*types.Transaction, error) { + return _Pool.Contract.RemoveLiquidityOneCoin(&_Pool.TransactOpts, _token_amount, i, _min_amount) +} + +// RemoveLiquidityOneCoin is a paid mutator transaction binding the contract method 0x1a4d01d2. +// +// Solidity: function remove_liquidity_one_coin(uint256 _token_amount, int128 i, uint256 _min_amount) returns(uint256) +func (_Pool *PoolTransactorSession) RemoveLiquidityOneCoin(_token_amount *big.Int, i *big.Int, _min_amount *big.Int) (*types.Transaction, error) { + return _Pool.Contract.RemoveLiquidityOneCoin(&_Pool.TransactOpts, _token_amount, i, _min_amount) +} + +// RemoveLiquidityOneCoin0 is a paid mutator transaction binding the contract method 0x517a55a3. +// +// Solidity: function remove_liquidity_one_coin(uint256 _token_amount, int128 i, uint256 _min_amount, bool _use_underlying) returns(uint256) +func (_Pool *PoolTransactor) RemoveLiquidityOneCoin0(opts *bind.TransactOpts, _token_amount *big.Int, i *big.Int, _min_amount *big.Int, _use_underlying bool) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "remove_liquidity_one_coin0", _token_amount, i, _min_amount, _use_underlying) +} + +// RemoveLiquidityOneCoin0 is a paid mutator transaction binding the contract method 0x517a55a3. +// +// Solidity: function remove_liquidity_one_coin(uint256 _token_amount, int128 i, uint256 _min_amount, bool _use_underlying) returns(uint256) +func (_Pool *PoolSession) RemoveLiquidityOneCoin0(_token_amount *big.Int, i *big.Int, _min_amount *big.Int, _use_underlying bool) (*types.Transaction, error) { + return _Pool.Contract.RemoveLiquidityOneCoin0(&_Pool.TransactOpts, _token_amount, i, _min_amount, _use_underlying) +} + +// RemoveLiquidityOneCoin0 is a paid mutator transaction binding the contract method 0x517a55a3. +// +// Solidity: function remove_liquidity_one_coin(uint256 _token_amount, int128 i, uint256 _min_amount, bool _use_underlying) returns(uint256) +func (_Pool *PoolTransactorSession) RemoveLiquidityOneCoin0(_token_amount *big.Int, i *big.Int, _min_amount *big.Int, _use_underlying bool) (*types.Transaction, error) { + return _Pool.Contract.RemoveLiquidityOneCoin0(&_Pool.TransactOpts, _token_amount, i, _min_amount, _use_underlying) +} + +// RevertNewParameters is a paid mutator transaction binding the contract method 0x226840fb. +// +// Solidity: function revert_new_parameters() returns() +func (_Pool *PoolTransactor) RevertNewParameters(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "revert_new_parameters") +} + +// RevertNewParameters is a paid mutator transaction binding the contract method 0x226840fb. +// +// Solidity: function revert_new_parameters() returns() +func (_Pool *PoolSession) RevertNewParameters() (*types.Transaction, error) { + return _Pool.Contract.RevertNewParameters(&_Pool.TransactOpts) +} + +// RevertNewParameters is a paid mutator transaction binding the contract method 0x226840fb. +// +// Solidity: function revert_new_parameters() returns() +func (_Pool *PoolTransactorSession) RevertNewParameters() (*types.Transaction, error) { + return _Pool.Contract.RevertNewParameters(&_Pool.TransactOpts) +} + +// RevertTransferOwnership is a paid mutator transaction binding the contract method 0x86fbf193. +// +// Solidity: function revert_transfer_ownership() returns() +func (_Pool *PoolTransactor) RevertTransferOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "revert_transfer_ownership") +} + +// RevertTransferOwnership is a paid mutator transaction binding the contract method 0x86fbf193. +// +// Solidity: function revert_transfer_ownership() returns() +func (_Pool *PoolSession) RevertTransferOwnership() (*types.Transaction, error) { + return _Pool.Contract.RevertTransferOwnership(&_Pool.TransactOpts) +} + +// RevertTransferOwnership is a paid mutator transaction binding the contract method 0x86fbf193. +// +// Solidity: function revert_transfer_ownership() returns() +func (_Pool *PoolTransactorSession) RevertTransferOwnership() (*types.Transaction, error) { + return _Pool.Contract.RevertTransferOwnership(&_Pool.TransactOpts) +} + +// SetAaveReferral is a paid mutator transaction binding the contract method 0xb6aa64c5. +// +// Solidity: function set_aave_referral(uint256 referral_code) returns() +func (_Pool *PoolTransactor) SetAaveReferral(opts *bind.TransactOpts, referral_code *big.Int) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "set_aave_referral", referral_code) +} + +// SetAaveReferral is a paid mutator transaction binding the contract method 0xb6aa64c5. +// +// Solidity: function set_aave_referral(uint256 referral_code) returns() +func (_Pool *PoolSession) SetAaveReferral(referral_code *big.Int) (*types.Transaction, error) { + return _Pool.Contract.SetAaveReferral(&_Pool.TransactOpts, referral_code) +} + +// SetAaveReferral is a paid mutator transaction binding the contract method 0xb6aa64c5. +// +// Solidity: function set_aave_referral(uint256 referral_code) returns() +func (_Pool *PoolTransactorSession) SetAaveReferral(referral_code *big.Int) (*types.Transaction, error) { + return _Pool.Contract.SetAaveReferral(&_Pool.TransactOpts, referral_code) +} + +// SetAdminFeeReceiver is a paid mutator transaction binding the contract method 0x7242e524. +// +// Solidity: function set_admin_fee_receiver(address _admin_fee_receiver) returns() +func (_Pool *PoolTransactor) SetAdminFeeReceiver(opts *bind.TransactOpts, _admin_fee_receiver common.Address) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "set_admin_fee_receiver", _admin_fee_receiver) +} + +// SetAdminFeeReceiver is a paid mutator transaction binding the contract method 0x7242e524. +// +// Solidity: function set_admin_fee_receiver(address _admin_fee_receiver) returns() +func (_Pool *PoolSession) SetAdminFeeReceiver(_admin_fee_receiver common.Address) (*types.Transaction, error) { + return _Pool.Contract.SetAdminFeeReceiver(&_Pool.TransactOpts, _admin_fee_receiver) +} + +// SetAdminFeeReceiver is a paid mutator transaction binding the contract method 0x7242e524. +// +// Solidity: function set_admin_fee_receiver(address _admin_fee_receiver) returns() +func (_Pool *PoolTransactorSession) SetAdminFeeReceiver(_admin_fee_receiver common.Address) (*types.Transaction, error) { + return _Pool.Contract.SetAdminFeeReceiver(&_Pool.TransactOpts, _admin_fee_receiver) +} + +// SetRewardReceiver is a paid mutator transaction binding the contract method 0xc51b8861. +// +// Solidity: function set_reward_receiver(address _reward_receiver) returns() +func (_Pool *PoolTransactor) SetRewardReceiver(opts *bind.TransactOpts, _reward_receiver common.Address) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "set_reward_receiver", _reward_receiver) +} + +// SetRewardReceiver is a paid mutator transaction binding the contract method 0xc51b8861. +// +// Solidity: function set_reward_receiver(address _reward_receiver) returns() +func (_Pool *PoolSession) SetRewardReceiver(_reward_receiver common.Address) (*types.Transaction, error) { + return _Pool.Contract.SetRewardReceiver(&_Pool.TransactOpts, _reward_receiver) +} + +// SetRewardReceiver is a paid mutator transaction binding the contract method 0xc51b8861. +// +// Solidity: function set_reward_receiver(address _reward_receiver) returns() +func (_Pool *PoolTransactorSession) SetRewardReceiver(_reward_receiver common.Address) (*types.Transaction, error) { + return _Pool.Contract.SetRewardReceiver(&_Pool.TransactOpts, _reward_receiver) +} + +// StopRampA is a paid mutator transaction binding the contract method 0x551a6588. +// +// Solidity: function stop_ramp_A() returns() +func (_Pool *PoolTransactor) StopRampA(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "stop_ramp_A") +} + +// StopRampA is a paid mutator transaction binding the contract method 0x551a6588. +// +// Solidity: function stop_ramp_A() returns() +func (_Pool *PoolSession) StopRampA() (*types.Transaction, error) { + return _Pool.Contract.StopRampA(&_Pool.TransactOpts) +} + +// StopRampA is a paid mutator transaction binding the contract method 0x551a6588. +// +// Solidity: function stop_ramp_A() returns() +func (_Pool *PoolTransactorSession) StopRampA() (*types.Transaction, error) { + return _Pool.Contract.StopRampA(&_Pool.TransactOpts) +} + +// UnkillMe is a paid mutator transaction binding the contract method 0x3046f972. +// +// Solidity: function unkill_me() returns() +func (_Pool *PoolTransactor) UnkillMe(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "unkill_me") +} + +// UnkillMe is a paid mutator transaction binding the contract method 0x3046f972. +// +// Solidity: function unkill_me() returns() +func (_Pool *PoolSession) UnkillMe() (*types.Transaction, error) { + return _Pool.Contract.UnkillMe(&_Pool.TransactOpts) +} + +// UnkillMe is a paid mutator transaction binding the contract method 0x3046f972. +// +// Solidity: function unkill_me() returns() +func (_Pool *PoolTransactorSession) UnkillMe() (*types.Transaction, error) { + return _Pool.Contract.UnkillMe(&_Pool.TransactOpts) +} + +// WithdrawAdminFees is a paid mutator transaction binding the contract method 0x30c54085. +// +// Solidity: function withdraw_admin_fees() returns() +func (_Pool *PoolTransactor) WithdrawAdminFees(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Pool.contract.Transact(opts, "withdraw_admin_fees") +} + +// WithdrawAdminFees is a paid mutator transaction binding the contract method 0x30c54085. +// +// Solidity: function withdraw_admin_fees() returns() +func (_Pool *PoolSession) WithdrawAdminFees() (*types.Transaction, error) { + return _Pool.Contract.WithdrawAdminFees(&_Pool.TransactOpts) +} + +// WithdrawAdminFees is a paid mutator transaction binding the contract method 0x30c54085. +// +// Solidity: function withdraw_admin_fees() returns() +func (_Pool *PoolTransactorSession) WithdrawAdminFees() (*types.Transaction, error) { + return _Pool.Contract.WithdrawAdminFees(&_Pool.TransactOpts) +} + +// PoolAddLiquidityIterator is returned from FilterAddLiquidity and is used to iterate over the raw logs and unpacked data for AddLiquidity events raised by the Pool contract. +type PoolAddLiquidityIterator struct { + Event *PoolAddLiquidity // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PoolAddLiquidityIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PoolAddLiquidity) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PoolAddLiquidity) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PoolAddLiquidityIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PoolAddLiquidityIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PoolAddLiquidity represents a AddLiquidity event raised by the Pool contract. +type PoolAddLiquidity struct { + Provider common.Address + TokenAmounts [3]*big.Int + Fees [3]*big.Int + Invariant *big.Int + TokenSupply *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterAddLiquidity is a free log retrieval operation binding the contract event 0x423f6495a08fc652425cf4ed0d1f9e37e571d9b9529b1c1c23cce780b2e7df0d. +// +// Solidity: event AddLiquidity(address indexed provider, uint256[3] token_amounts, uint256[3] fees, uint256 invariant, uint256 token_supply) +func (_Pool *PoolFilterer) FilterAddLiquidity(opts *bind.FilterOpts, provider []common.Address) (*PoolAddLiquidityIterator, error) { + + var providerRule []interface{} + for _, providerItem := range provider { + providerRule = append(providerRule, providerItem) + } + + logs, sub, err := _Pool.contract.FilterLogs(opts, "AddLiquidity", providerRule) + if err != nil { + return nil, err + } + return &PoolAddLiquidityIterator{contract: _Pool.contract, event: "AddLiquidity", logs: logs, sub: sub}, nil +} + +// WatchAddLiquidity is a free log subscription operation binding the contract event 0x423f6495a08fc652425cf4ed0d1f9e37e571d9b9529b1c1c23cce780b2e7df0d. +// +// Solidity: event AddLiquidity(address indexed provider, uint256[3] token_amounts, uint256[3] fees, uint256 invariant, uint256 token_supply) +func (_Pool *PoolFilterer) WatchAddLiquidity(opts *bind.WatchOpts, sink chan<- *PoolAddLiquidity, provider []common.Address) (event.Subscription, error) { + + var providerRule []interface{} + for _, providerItem := range provider { + providerRule = append(providerRule, providerItem) + } + + logs, sub, err := _Pool.contract.WatchLogs(opts, "AddLiquidity", providerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PoolAddLiquidity) + if err := _Pool.contract.UnpackLog(event, "AddLiquidity", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseAddLiquidity is a log parse operation binding the contract event 0x423f6495a08fc652425cf4ed0d1f9e37e571d9b9529b1c1c23cce780b2e7df0d. +// +// Solidity: event AddLiquidity(address indexed provider, uint256[3] token_amounts, uint256[3] fees, uint256 invariant, uint256 token_supply) +func (_Pool *PoolFilterer) ParseAddLiquidity(log types.Log) (*PoolAddLiquidity, error) { + event := new(PoolAddLiquidity) + if err := _Pool.contract.UnpackLog(event, "AddLiquidity", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PoolCommitNewAdminIterator is returned from FilterCommitNewAdmin and is used to iterate over the raw logs and unpacked data for CommitNewAdmin events raised by the Pool contract. +type PoolCommitNewAdminIterator struct { + Event *PoolCommitNewAdmin // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PoolCommitNewAdminIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PoolCommitNewAdmin) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PoolCommitNewAdmin) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PoolCommitNewAdminIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PoolCommitNewAdminIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PoolCommitNewAdmin represents a CommitNewAdmin event raised by the Pool contract. +type PoolCommitNewAdmin struct { + Deadline *big.Int + Admin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterCommitNewAdmin is a free log retrieval operation binding the contract event 0x181aa3aa17d4cbf99265dd4443eba009433d3cde79d60164fde1d1a192beb935. +// +// Solidity: event CommitNewAdmin(uint256 indexed deadline, address indexed admin) +func (_Pool *PoolFilterer) FilterCommitNewAdmin(opts *bind.FilterOpts, deadline []*big.Int, admin []common.Address) (*PoolCommitNewAdminIterator, error) { + + var deadlineRule []interface{} + for _, deadlineItem := range deadline { + deadlineRule = append(deadlineRule, deadlineItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _Pool.contract.FilterLogs(opts, "CommitNewAdmin", deadlineRule, adminRule) + if err != nil { + return nil, err + } + return &PoolCommitNewAdminIterator{contract: _Pool.contract, event: "CommitNewAdmin", logs: logs, sub: sub}, nil +} + +// WatchCommitNewAdmin is a free log subscription operation binding the contract event 0x181aa3aa17d4cbf99265dd4443eba009433d3cde79d60164fde1d1a192beb935. +// +// Solidity: event CommitNewAdmin(uint256 indexed deadline, address indexed admin) +func (_Pool *PoolFilterer) WatchCommitNewAdmin(opts *bind.WatchOpts, sink chan<- *PoolCommitNewAdmin, deadline []*big.Int, admin []common.Address) (event.Subscription, error) { + + var deadlineRule []interface{} + for _, deadlineItem := range deadline { + deadlineRule = append(deadlineRule, deadlineItem) + } + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _Pool.contract.WatchLogs(opts, "CommitNewAdmin", deadlineRule, adminRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PoolCommitNewAdmin) + if err := _Pool.contract.UnpackLog(event, "CommitNewAdmin", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseCommitNewAdmin is a log parse operation binding the contract event 0x181aa3aa17d4cbf99265dd4443eba009433d3cde79d60164fde1d1a192beb935. +// +// Solidity: event CommitNewAdmin(uint256 indexed deadline, address indexed admin) +func (_Pool *PoolFilterer) ParseCommitNewAdmin(log types.Log) (*PoolCommitNewAdmin, error) { + event := new(PoolCommitNewAdmin) + if err := _Pool.contract.UnpackLog(event, "CommitNewAdmin", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PoolCommitNewFeeIterator is returned from FilterCommitNewFee and is used to iterate over the raw logs and unpacked data for CommitNewFee events raised by the Pool contract. +type PoolCommitNewFeeIterator struct { + Event *PoolCommitNewFee // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PoolCommitNewFeeIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PoolCommitNewFee) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PoolCommitNewFee) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PoolCommitNewFeeIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PoolCommitNewFeeIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PoolCommitNewFee represents a CommitNewFee event raised by the Pool contract. +type PoolCommitNewFee struct { + Deadline *big.Int + Fee *big.Int + AdminFee *big.Int + OffpegFeeMultiplier *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterCommitNewFee is a free log retrieval operation binding the contract event 0xe347cde074ab87e09449fa2b03e8f2cf79094cb1265f4c914365d2247d4147a3. +// +// Solidity: event CommitNewFee(uint256 indexed deadline, uint256 fee, uint256 admin_fee, uint256 offpeg_fee_multiplier) +func (_Pool *PoolFilterer) FilterCommitNewFee(opts *bind.FilterOpts, deadline []*big.Int) (*PoolCommitNewFeeIterator, error) { + + var deadlineRule []interface{} + for _, deadlineItem := range deadline { + deadlineRule = append(deadlineRule, deadlineItem) + } + + logs, sub, err := _Pool.contract.FilterLogs(opts, "CommitNewFee", deadlineRule) + if err != nil { + return nil, err + } + return &PoolCommitNewFeeIterator{contract: _Pool.contract, event: "CommitNewFee", logs: logs, sub: sub}, nil +} + +// WatchCommitNewFee is a free log subscription operation binding the contract event 0xe347cde074ab87e09449fa2b03e8f2cf79094cb1265f4c914365d2247d4147a3. +// +// Solidity: event CommitNewFee(uint256 indexed deadline, uint256 fee, uint256 admin_fee, uint256 offpeg_fee_multiplier) +func (_Pool *PoolFilterer) WatchCommitNewFee(opts *bind.WatchOpts, sink chan<- *PoolCommitNewFee, deadline []*big.Int) (event.Subscription, error) { + + var deadlineRule []interface{} + for _, deadlineItem := range deadline { + deadlineRule = append(deadlineRule, deadlineItem) + } + + logs, sub, err := _Pool.contract.WatchLogs(opts, "CommitNewFee", deadlineRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PoolCommitNewFee) + if err := _Pool.contract.UnpackLog(event, "CommitNewFee", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseCommitNewFee is a log parse operation binding the contract event 0xe347cde074ab87e09449fa2b03e8f2cf79094cb1265f4c914365d2247d4147a3. +// +// Solidity: event CommitNewFee(uint256 indexed deadline, uint256 fee, uint256 admin_fee, uint256 offpeg_fee_multiplier) +func (_Pool *PoolFilterer) ParseCommitNewFee(log types.Log) (*PoolCommitNewFee, error) { + event := new(PoolCommitNewFee) + if err := _Pool.contract.UnpackLog(event, "CommitNewFee", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PoolNewAdminIterator is returned from FilterNewAdmin and is used to iterate over the raw logs and unpacked data for NewAdmin events raised by the Pool contract. +type PoolNewAdminIterator struct { + Event *PoolNewAdmin // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PoolNewAdminIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PoolNewAdmin) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PoolNewAdmin) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PoolNewAdminIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PoolNewAdminIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PoolNewAdmin represents a NewAdmin event raised by the Pool contract. +type PoolNewAdmin struct { + Admin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterNewAdmin is a free log retrieval operation binding the contract event 0x71614071b88dee5e0b2ae578a9dd7b2ebbe9ae832ba419dc0242cd065a290b6c. +// +// Solidity: event NewAdmin(address indexed admin) +func (_Pool *PoolFilterer) FilterNewAdmin(opts *bind.FilterOpts, admin []common.Address) (*PoolNewAdminIterator, error) { + + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _Pool.contract.FilterLogs(opts, "NewAdmin", adminRule) + if err != nil { + return nil, err + } + return &PoolNewAdminIterator{contract: _Pool.contract, event: "NewAdmin", logs: logs, sub: sub}, nil +} + +// WatchNewAdmin is a free log subscription operation binding the contract event 0x71614071b88dee5e0b2ae578a9dd7b2ebbe9ae832ba419dc0242cd065a290b6c. +// +// Solidity: event NewAdmin(address indexed admin) +func (_Pool *PoolFilterer) WatchNewAdmin(opts *bind.WatchOpts, sink chan<- *PoolNewAdmin, admin []common.Address) (event.Subscription, error) { + + var adminRule []interface{} + for _, adminItem := range admin { + adminRule = append(adminRule, adminItem) + } + + logs, sub, err := _Pool.contract.WatchLogs(opts, "NewAdmin", adminRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PoolNewAdmin) + if err := _Pool.contract.UnpackLog(event, "NewAdmin", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseNewAdmin is a log parse operation binding the contract event 0x71614071b88dee5e0b2ae578a9dd7b2ebbe9ae832ba419dc0242cd065a290b6c. +// +// Solidity: event NewAdmin(address indexed admin) +func (_Pool *PoolFilterer) ParseNewAdmin(log types.Log) (*PoolNewAdmin, error) { + event := new(PoolNewAdmin) + if err := _Pool.contract.UnpackLog(event, "NewAdmin", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PoolNewFeeIterator is returned from FilterNewFee and is used to iterate over the raw logs and unpacked data for NewFee events raised by the Pool contract. +type PoolNewFeeIterator struct { + Event *PoolNewFee // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PoolNewFeeIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PoolNewFee) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PoolNewFee) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PoolNewFeeIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PoolNewFeeIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PoolNewFee represents a NewFee event raised by the Pool contract. +type PoolNewFee struct { + Fee *big.Int + AdminFee *big.Int + OffpegFeeMultiplier *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterNewFee is a free log retrieval operation binding the contract event 0xcfca96e0fef3432146913b2a5a2268a55d3f475fe057e7ffde1082b77693f4f3. +// +// Solidity: event NewFee(uint256 fee, uint256 admin_fee, uint256 offpeg_fee_multiplier) +func (_Pool *PoolFilterer) FilterNewFee(opts *bind.FilterOpts) (*PoolNewFeeIterator, error) { + + logs, sub, err := _Pool.contract.FilterLogs(opts, "NewFee") + if err != nil { + return nil, err + } + return &PoolNewFeeIterator{contract: _Pool.contract, event: "NewFee", logs: logs, sub: sub}, nil +} + +// WatchNewFee is a free log subscription operation binding the contract event 0xcfca96e0fef3432146913b2a5a2268a55d3f475fe057e7ffde1082b77693f4f3. +// +// Solidity: event NewFee(uint256 fee, uint256 admin_fee, uint256 offpeg_fee_multiplier) +func (_Pool *PoolFilterer) WatchNewFee(opts *bind.WatchOpts, sink chan<- *PoolNewFee) (event.Subscription, error) { + + logs, sub, err := _Pool.contract.WatchLogs(opts, "NewFee") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PoolNewFee) + if err := _Pool.contract.UnpackLog(event, "NewFee", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseNewFee is a log parse operation binding the contract event 0xcfca96e0fef3432146913b2a5a2268a55d3f475fe057e7ffde1082b77693f4f3. +// +// Solidity: event NewFee(uint256 fee, uint256 admin_fee, uint256 offpeg_fee_multiplier) +func (_Pool *PoolFilterer) ParseNewFee(log types.Log) (*PoolNewFee, error) { + event := new(PoolNewFee) + if err := _Pool.contract.UnpackLog(event, "NewFee", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PoolRampAIterator is returned from FilterRampA and is used to iterate over the raw logs and unpacked data for RampA events raised by the Pool contract. +type PoolRampAIterator struct { + Event *PoolRampA // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PoolRampAIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PoolRampA) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PoolRampA) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PoolRampAIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PoolRampAIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PoolRampA represents a RampA event raised by the Pool contract. +type PoolRampA struct { + OldA *big.Int + NewA *big.Int + InitialTime *big.Int + FutureTime *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterRampA is a free log retrieval operation binding the contract event 0xa2b71ec6df949300b59aab36b55e189697b750119dd349fcfa8c0f779e83c254. +// +// Solidity: event RampA(uint256 old_A, uint256 new_A, uint256 initial_time, uint256 future_time) +func (_Pool *PoolFilterer) FilterRampA(opts *bind.FilterOpts) (*PoolRampAIterator, error) { + + logs, sub, err := _Pool.contract.FilterLogs(opts, "RampA") + if err != nil { + return nil, err + } + return &PoolRampAIterator{contract: _Pool.contract, event: "RampA", logs: logs, sub: sub}, nil +} + +// WatchRampA is a free log subscription operation binding the contract event 0xa2b71ec6df949300b59aab36b55e189697b750119dd349fcfa8c0f779e83c254. +// +// Solidity: event RampA(uint256 old_A, uint256 new_A, uint256 initial_time, uint256 future_time) +func (_Pool *PoolFilterer) WatchRampA(opts *bind.WatchOpts, sink chan<- *PoolRampA) (event.Subscription, error) { + + logs, sub, err := _Pool.contract.WatchLogs(opts, "RampA") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PoolRampA) + if err := _Pool.contract.UnpackLog(event, "RampA", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseRampA is a log parse operation binding the contract event 0xa2b71ec6df949300b59aab36b55e189697b750119dd349fcfa8c0f779e83c254. +// +// Solidity: event RampA(uint256 old_A, uint256 new_A, uint256 initial_time, uint256 future_time) +func (_Pool *PoolFilterer) ParseRampA(log types.Log) (*PoolRampA, error) { + event := new(PoolRampA) + if err := _Pool.contract.UnpackLog(event, "RampA", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PoolRemoveLiquidityIterator is returned from FilterRemoveLiquidity and is used to iterate over the raw logs and unpacked data for RemoveLiquidity events raised by the Pool contract. +type PoolRemoveLiquidityIterator struct { + Event *PoolRemoveLiquidity // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PoolRemoveLiquidityIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PoolRemoveLiquidity) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PoolRemoveLiquidity) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PoolRemoveLiquidityIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PoolRemoveLiquidityIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PoolRemoveLiquidity represents a RemoveLiquidity event raised by the Pool contract. +type PoolRemoveLiquidity struct { + Provider common.Address + TokenAmounts [3]*big.Int + Fees [3]*big.Int + TokenSupply *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterRemoveLiquidity is a free log retrieval operation binding the contract event 0xa49d4cf02656aebf8c771f5a8585638a2a15ee6c97cf7205d4208ed7c1df252d. +// +// Solidity: event RemoveLiquidity(address indexed provider, uint256[3] token_amounts, uint256[3] fees, uint256 token_supply) +func (_Pool *PoolFilterer) FilterRemoveLiquidity(opts *bind.FilterOpts, provider []common.Address) (*PoolRemoveLiquidityIterator, error) { + + var providerRule []interface{} + for _, providerItem := range provider { + providerRule = append(providerRule, providerItem) + } + + logs, sub, err := _Pool.contract.FilterLogs(opts, "RemoveLiquidity", providerRule) + if err != nil { + return nil, err + } + return &PoolRemoveLiquidityIterator{contract: _Pool.contract, event: "RemoveLiquidity", logs: logs, sub: sub}, nil +} + +// WatchRemoveLiquidity is a free log subscription operation binding the contract event 0xa49d4cf02656aebf8c771f5a8585638a2a15ee6c97cf7205d4208ed7c1df252d. +// +// Solidity: event RemoveLiquidity(address indexed provider, uint256[3] token_amounts, uint256[3] fees, uint256 token_supply) +func (_Pool *PoolFilterer) WatchRemoveLiquidity(opts *bind.WatchOpts, sink chan<- *PoolRemoveLiquidity, provider []common.Address) (event.Subscription, error) { + + var providerRule []interface{} + for _, providerItem := range provider { + providerRule = append(providerRule, providerItem) + } + + logs, sub, err := _Pool.contract.WatchLogs(opts, "RemoveLiquidity", providerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PoolRemoveLiquidity) + if err := _Pool.contract.UnpackLog(event, "RemoveLiquidity", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseRemoveLiquidity is a log parse operation binding the contract event 0xa49d4cf02656aebf8c771f5a8585638a2a15ee6c97cf7205d4208ed7c1df252d. +// +// Solidity: event RemoveLiquidity(address indexed provider, uint256[3] token_amounts, uint256[3] fees, uint256 token_supply) +func (_Pool *PoolFilterer) ParseRemoveLiquidity(log types.Log) (*PoolRemoveLiquidity, error) { + event := new(PoolRemoveLiquidity) + if err := _Pool.contract.UnpackLog(event, "RemoveLiquidity", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PoolRemoveLiquidityImbalanceIterator is returned from FilterRemoveLiquidityImbalance and is used to iterate over the raw logs and unpacked data for RemoveLiquidityImbalance events raised by the Pool contract. +type PoolRemoveLiquidityImbalanceIterator struct { + Event *PoolRemoveLiquidityImbalance // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PoolRemoveLiquidityImbalanceIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PoolRemoveLiquidityImbalance) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PoolRemoveLiquidityImbalance) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PoolRemoveLiquidityImbalanceIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PoolRemoveLiquidityImbalanceIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PoolRemoveLiquidityImbalance represents a RemoveLiquidityImbalance event raised by the Pool contract. +type PoolRemoveLiquidityImbalance struct { + Provider common.Address + TokenAmounts [3]*big.Int + Fees [3]*big.Int + Invariant *big.Int + TokenSupply *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterRemoveLiquidityImbalance is a free log retrieval operation binding the contract event 0x173599dbf9c6ca6f7c3b590df07ae98a45d74ff54065505141e7de6c46a624c2. +// +// Solidity: event RemoveLiquidityImbalance(address indexed provider, uint256[3] token_amounts, uint256[3] fees, uint256 invariant, uint256 token_supply) +func (_Pool *PoolFilterer) FilterRemoveLiquidityImbalance(opts *bind.FilterOpts, provider []common.Address) (*PoolRemoveLiquidityImbalanceIterator, error) { + + var providerRule []interface{} + for _, providerItem := range provider { + providerRule = append(providerRule, providerItem) + } + + logs, sub, err := _Pool.contract.FilterLogs(opts, "RemoveLiquidityImbalance", providerRule) + if err != nil { + return nil, err + } + return &PoolRemoveLiquidityImbalanceIterator{contract: _Pool.contract, event: "RemoveLiquidityImbalance", logs: logs, sub: sub}, nil +} + +// WatchRemoveLiquidityImbalance is a free log subscription operation binding the contract event 0x173599dbf9c6ca6f7c3b590df07ae98a45d74ff54065505141e7de6c46a624c2. +// +// Solidity: event RemoveLiquidityImbalance(address indexed provider, uint256[3] token_amounts, uint256[3] fees, uint256 invariant, uint256 token_supply) +func (_Pool *PoolFilterer) WatchRemoveLiquidityImbalance(opts *bind.WatchOpts, sink chan<- *PoolRemoveLiquidityImbalance, provider []common.Address) (event.Subscription, error) { + + var providerRule []interface{} + for _, providerItem := range provider { + providerRule = append(providerRule, providerItem) + } + + logs, sub, err := _Pool.contract.WatchLogs(opts, "RemoveLiquidityImbalance", providerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PoolRemoveLiquidityImbalance) + if err := _Pool.contract.UnpackLog(event, "RemoveLiquidityImbalance", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseRemoveLiquidityImbalance is a log parse operation binding the contract event 0x173599dbf9c6ca6f7c3b590df07ae98a45d74ff54065505141e7de6c46a624c2. +// +// Solidity: event RemoveLiquidityImbalance(address indexed provider, uint256[3] token_amounts, uint256[3] fees, uint256 invariant, uint256 token_supply) +func (_Pool *PoolFilterer) ParseRemoveLiquidityImbalance(log types.Log) (*PoolRemoveLiquidityImbalance, error) { + event := new(PoolRemoveLiquidityImbalance) + if err := _Pool.contract.UnpackLog(event, "RemoveLiquidityImbalance", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PoolRemoveLiquidityOneIterator is returned from FilterRemoveLiquidityOne and is used to iterate over the raw logs and unpacked data for RemoveLiquidityOne events raised by the Pool contract. +type PoolRemoveLiquidityOneIterator struct { + Event *PoolRemoveLiquidityOne // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PoolRemoveLiquidityOneIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PoolRemoveLiquidityOne) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PoolRemoveLiquidityOne) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PoolRemoveLiquidityOneIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PoolRemoveLiquidityOneIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PoolRemoveLiquidityOne represents a RemoveLiquidityOne event raised by the Pool contract. +type PoolRemoveLiquidityOne struct { + Provider common.Address + TokenAmount *big.Int + CoinAmount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterRemoveLiquidityOne is a free log retrieval operation binding the contract event 0x9e96dd3b997a2a257eec4df9bb6eaf626e206df5f543bd963682d143300be310. +// +// Solidity: event RemoveLiquidityOne(address indexed provider, uint256 token_amount, uint256 coin_amount) +func (_Pool *PoolFilterer) FilterRemoveLiquidityOne(opts *bind.FilterOpts, provider []common.Address) (*PoolRemoveLiquidityOneIterator, error) { + + var providerRule []interface{} + for _, providerItem := range provider { + providerRule = append(providerRule, providerItem) + } + + logs, sub, err := _Pool.contract.FilterLogs(opts, "RemoveLiquidityOne", providerRule) + if err != nil { + return nil, err + } + return &PoolRemoveLiquidityOneIterator{contract: _Pool.contract, event: "RemoveLiquidityOne", logs: logs, sub: sub}, nil +} + +// WatchRemoveLiquidityOne is a free log subscription operation binding the contract event 0x9e96dd3b997a2a257eec4df9bb6eaf626e206df5f543bd963682d143300be310. +// +// Solidity: event RemoveLiquidityOne(address indexed provider, uint256 token_amount, uint256 coin_amount) +func (_Pool *PoolFilterer) WatchRemoveLiquidityOne(opts *bind.WatchOpts, sink chan<- *PoolRemoveLiquidityOne, provider []common.Address) (event.Subscription, error) { + + var providerRule []interface{} + for _, providerItem := range provider { + providerRule = append(providerRule, providerItem) + } + + logs, sub, err := _Pool.contract.WatchLogs(opts, "RemoveLiquidityOne", providerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PoolRemoveLiquidityOne) + if err := _Pool.contract.UnpackLog(event, "RemoveLiquidityOne", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseRemoveLiquidityOne is a log parse operation binding the contract event 0x9e96dd3b997a2a257eec4df9bb6eaf626e206df5f543bd963682d143300be310. +// +// Solidity: event RemoveLiquidityOne(address indexed provider, uint256 token_amount, uint256 coin_amount) +func (_Pool *PoolFilterer) ParseRemoveLiquidityOne(log types.Log) (*PoolRemoveLiquidityOne, error) { + event := new(PoolRemoveLiquidityOne) + if err := _Pool.contract.UnpackLog(event, "RemoveLiquidityOne", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PoolStopRampAIterator is returned from FilterStopRampA and is used to iterate over the raw logs and unpacked data for StopRampA events raised by the Pool contract. +type PoolStopRampAIterator struct { + Event *PoolStopRampA // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PoolStopRampAIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PoolStopRampA) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PoolStopRampA) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PoolStopRampAIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PoolStopRampAIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PoolStopRampA represents a StopRampA event raised by the Pool contract. +type PoolStopRampA struct { + A *big.Int + T *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterStopRampA is a free log retrieval operation binding the contract event 0x46e22fb3709ad289f62ce63d469248536dbc78d82b84a3d7e74ad606dc201938. +// +// Solidity: event StopRampA(uint256 A, uint256 t) +func (_Pool *PoolFilterer) FilterStopRampA(opts *bind.FilterOpts) (*PoolStopRampAIterator, error) { + + logs, sub, err := _Pool.contract.FilterLogs(opts, "StopRampA") + if err != nil { + return nil, err + } + return &PoolStopRampAIterator{contract: _Pool.contract, event: "StopRampA", logs: logs, sub: sub}, nil +} + +// WatchStopRampA is a free log subscription operation binding the contract event 0x46e22fb3709ad289f62ce63d469248536dbc78d82b84a3d7e74ad606dc201938. +// +// Solidity: event StopRampA(uint256 A, uint256 t) +func (_Pool *PoolFilterer) WatchStopRampA(opts *bind.WatchOpts, sink chan<- *PoolStopRampA) (event.Subscription, error) { + + logs, sub, err := _Pool.contract.WatchLogs(opts, "StopRampA") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PoolStopRampA) + if err := _Pool.contract.UnpackLog(event, "StopRampA", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseStopRampA is a log parse operation binding the contract event 0x46e22fb3709ad289f62ce63d469248536dbc78d82b84a3d7e74ad606dc201938. +// +// Solidity: event StopRampA(uint256 A, uint256 t) +func (_Pool *PoolFilterer) ParseStopRampA(log types.Log) (*PoolStopRampA, error) { + event := new(PoolStopRampA) + if err := _Pool.contract.UnpackLog(event, "StopRampA", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PoolTokenExchangeIterator is returned from FilterTokenExchange and is used to iterate over the raw logs and unpacked data for TokenExchange events raised by the Pool contract. +type PoolTokenExchangeIterator struct { + Event *PoolTokenExchange // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PoolTokenExchangeIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PoolTokenExchange) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PoolTokenExchange) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PoolTokenExchangeIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PoolTokenExchangeIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PoolTokenExchange represents a TokenExchange event raised by the Pool contract. +type PoolTokenExchange struct { + Buyer common.Address + SoldId *big.Int + TokensSold *big.Int + BoughtId *big.Int + TokensBought *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTokenExchange is a free log retrieval operation binding the contract event 0x8b3e96f2b889fa771c53c981b40daf005f63f637f1869f707052d15a3dd97140. +// +// Solidity: event TokenExchange(address indexed buyer, int128 sold_id, uint256 tokens_sold, int128 bought_id, uint256 tokens_bought) +func (_Pool *PoolFilterer) FilterTokenExchange(opts *bind.FilterOpts, buyer []common.Address) (*PoolTokenExchangeIterator, error) { + + var buyerRule []interface{} + for _, buyerItem := range buyer { + buyerRule = append(buyerRule, buyerItem) + } + + logs, sub, err := _Pool.contract.FilterLogs(opts, "TokenExchange", buyerRule) + if err != nil { + return nil, err + } + return &PoolTokenExchangeIterator{contract: _Pool.contract, event: "TokenExchange", logs: logs, sub: sub}, nil +} + +// WatchTokenExchange is a free log subscription operation binding the contract event 0x8b3e96f2b889fa771c53c981b40daf005f63f637f1869f707052d15a3dd97140. +// +// Solidity: event TokenExchange(address indexed buyer, int128 sold_id, uint256 tokens_sold, int128 bought_id, uint256 tokens_bought) +func (_Pool *PoolFilterer) WatchTokenExchange(opts *bind.WatchOpts, sink chan<- *PoolTokenExchange, buyer []common.Address) (event.Subscription, error) { + + var buyerRule []interface{} + for _, buyerItem := range buyer { + buyerRule = append(buyerRule, buyerItem) + } + + logs, sub, err := _Pool.contract.WatchLogs(opts, "TokenExchange", buyerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PoolTokenExchange) + if err := _Pool.contract.UnpackLog(event, "TokenExchange", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTokenExchange is a log parse operation binding the contract event 0x8b3e96f2b889fa771c53c981b40daf005f63f637f1869f707052d15a3dd97140. +// +// Solidity: event TokenExchange(address indexed buyer, int128 sold_id, uint256 tokens_sold, int128 bought_id, uint256 tokens_bought) +func (_Pool *PoolFilterer) ParseTokenExchange(log types.Log) (*PoolTokenExchange, error) { + event := new(PoolTokenExchange) + if err := _Pool.contract.UnpackLog(event, "TokenExchange", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PoolTokenExchangeUnderlyingIterator is returned from FilterTokenExchangeUnderlying and is used to iterate over the raw logs and unpacked data for TokenExchangeUnderlying events raised by the Pool contract. +type PoolTokenExchangeUnderlyingIterator struct { + Event *PoolTokenExchangeUnderlying // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PoolTokenExchangeUnderlyingIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PoolTokenExchangeUnderlying) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PoolTokenExchangeUnderlying) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PoolTokenExchangeUnderlyingIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PoolTokenExchangeUnderlyingIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PoolTokenExchangeUnderlying represents a TokenExchangeUnderlying event raised by the Pool contract. +type PoolTokenExchangeUnderlying struct { + Buyer common.Address + SoldId *big.Int + TokensSold *big.Int + BoughtId *big.Int + TokensBought *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTokenExchangeUnderlying is a free log retrieval operation binding the contract event 0xd013ca23e77a65003c2c659c5442c00c805371b7fc1ebd4c206c41d1536bd90b. +// +// Solidity: event TokenExchangeUnderlying(address indexed buyer, int128 sold_id, uint256 tokens_sold, int128 bought_id, uint256 tokens_bought) +func (_Pool *PoolFilterer) FilterTokenExchangeUnderlying(opts *bind.FilterOpts, buyer []common.Address) (*PoolTokenExchangeUnderlyingIterator, error) { + + var buyerRule []interface{} + for _, buyerItem := range buyer { + buyerRule = append(buyerRule, buyerItem) + } + + logs, sub, err := _Pool.contract.FilterLogs(opts, "TokenExchangeUnderlying", buyerRule) + if err != nil { + return nil, err + } + return &PoolTokenExchangeUnderlyingIterator{contract: _Pool.contract, event: "TokenExchangeUnderlying", logs: logs, sub: sub}, nil +} + +// WatchTokenExchangeUnderlying is a free log subscription operation binding the contract event 0xd013ca23e77a65003c2c659c5442c00c805371b7fc1ebd4c206c41d1536bd90b. +// +// Solidity: event TokenExchangeUnderlying(address indexed buyer, int128 sold_id, uint256 tokens_sold, int128 bought_id, uint256 tokens_bought) +func (_Pool *PoolFilterer) WatchTokenExchangeUnderlying(opts *bind.WatchOpts, sink chan<- *PoolTokenExchangeUnderlying, buyer []common.Address) (event.Subscription, error) { + + var buyerRule []interface{} + for _, buyerItem := range buyer { + buyerRule = append(buyerRule, buyerItem) + } + + logs, sub, err := _Pool.contract.WatchLogs(opts, "TokenExchangeUnderlying", buyerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PoolTokenExchangeUnderlying) + if err := _Pool.contract.UnpackLog(event, "TokenExchangeUnderlying", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTokenExchangeUnderlying is a log parse operation binding the contract event 0xd013ca23e77a65003c2c659c5442c00c805371b7fc1ebd4c206c41d1536bd90b. +// +// Solidity: event TokenExchangeUnderlying(address indexed buyer, int128 sold_id, uint256 tokens_sold, int128 bought_id, uint256 tokens_bought) +func (_Pool *PoolFilterer) ParseTokenExchangeUnderlying(log types.Log) (*PoolTokenExchangeUnderlying, error) { + event := new(PoolTokenExchangeUnderlying) + if err := _Pool.contract.UnpackLog(event, "TokenExchangeUnderlying", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +}