3342 lines
136 KiB
Go
3342 lines
136 KiB
Go
// 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
|
|
}
|