laurent/evm
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
0afb017f22
evm/curve/contracts/pool.go

3342 lines
136 KiB
Go
Raw Normal View History

curve + aave + beefy
2021-11-14 19:08:53 +00:00
// 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\":\"_of
}
// 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
}
Reference in New Issue Copy Permalink