Created
March 16, 2022 08:18
-
-
Save daoleno/343bca58aa0feabe3b35d79aef770add to your computer and use it in GitHub Desktop.
Generated uniswap v2 code.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| // Code generated - DO NOT EDIT. | |
| // This file is a generated binding and any manual changes will be lost. | |
| package uniswap | |
| import ( | |
| "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 ( | |
| _ = big.NewInt | |
| _ = strings.NewReader | |
| _ = ethereum.NotFound | |
| _ = bind.Bind | |
| _ = common.Big1 | |
| _ = types.BloomLookup | |
| _ = event.NewSubscription | |
| ) | |
| // IERC20ABI is the input ABI used to generate the binding from. | |
| const IERC20ABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" | |
| // IERC20FuncSigs maps the 4-byte function signature to its string representation. | |
| var IERC20FuncSigs = map[string]string{ | |
| "dd62ed3e": "allowance(address,address)", | |
| "095ea7b3": "approve(address,uint256)", | |
| "70a08231": "balanceOf(address)", | |
| "313ce567": "decimals()", | |
| "06fdde03": "name()", | |
| "95d89b41": "symbol()", | |
| "18160ddd": "totalSupply()", | |
| "a9059cbb": "transfer(address,uint256)", | |
| "23b872dd": "transferFrom(address,address,uint256)", | |
| } | |
| // IERC20 is an auto generated Go binding around an Ethereum contract. | |
| type IERC20 struct { | |
| IERC20Caller // Read-only binding to the contract | |
| IERC20Transactor // Write-only binding to the contract | |
| IERC20Filterer // Log filterer for contract events | |
| } | |
| // IERC20Caller is an auto generated read-only Go binding around an Ethereum contract. | |
| type IERC20Caller struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // IERC20Transactor is an auto generated write-only Go binding around an Ethereum contract. | |
| type IERC20Transactor struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // IERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. | |
| type IERC20Filterer struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // IERC20Session is an auto generated Go binding around an Ethereum contract, | |
| // with pre-set call and transact options. | |
| type IERC20Session struct { | |
| Contract *IERC20 // 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 | |
| } | |
| // IERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract, | |
| // with pre-set call options. | |
| type IERC20CallerSession struct { | |
| Contract *IERC20Caller // Generic contract caller binding to set the session for | |
| CallOpts bind.CallOpts // Call options to use throughout this session | |
| } | |
| // IERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, | |
| // with pre-set transact options. | |
| type IERC20TransactorSession struct { | |
| Contract *IERC20Transactor // Generic contract transactor binding to set the session for | |
| TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session | |
| } | |
| // IERC20Raw is an auto generated low-level Go binding around an Ethereum contract. | |
| type IERC20Raw struct { | |
| Contract *IERC20 // Generic contract binding to access the raw methods on | |
| } | |
| // IERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. | |
| type IERC20CallerRaw struct { | |
| Contract *IERC20Caller // Generic read-only contract binding to access the raw methods on | |
| } | |
| // IERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. | |
| type IERC20TransactorRaw struct { | |
| Contract *IERC20Transactor // Generic write-only contract binding to access the raw methods on | |
| } | |
| // NewIERC20 creates a new instance of IERC20, bound to a specific deployed contract. | |
| func NewIERC20(address common.Address, backend bind.ContractBackend) (*IERC20, error) { | |
| contract, err := bindIERC20(address, backend, backend, backend) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IERC20{IERC20Caller: IERC20Caller{contract: contract}, IERC20Transactor: IERC20Transactor{contract: contract}, IERC20Filterer: IERC20Filterer{contract: contract}}, nil | |
| } | |
| // NewIERC20Caller creates a new read-only instance of IERC20, bound to a specific deployed contract. | |
| func NewIERC20Caller(address common.Address, caller bind.ContractCaller) (*IERC20Caller, error) { | |
| contract, err := bindIERC20(address, caller, nil, nil) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IERC20Caller{contract: contract}, nil | |
| } | |
| // NewIERC20Transactor creates a new write-only instance of IERC20, bound to a specific deployed contract. | |
| func NewIERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC20Transactor, error) { | |
| contract, err := bindIERC20(address, nil, transactor, nil) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IERC20Transactor{contract: contract}, nil | |
| } | |
| // NewIERC20Filterer creates a new log filterer instance of IERC20, bound to a specific deployed contract. | |
| func NewIERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC20Filterer, error) { | |
| contract, err := bindIERC20(address, nil, nil, filterer) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IERC20Filterer{contract: contract}, nil | |
| } | |
| // bindIERC20 binds a generic wrapper to an already deployed contract. | |
| func bindIERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { | |
| parsed, err := abi.JSON(strings.NewReader(IERC20ABI)) | |
| 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 (_IERC20 *IERC20Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { | |
| return _IERC20.Contract.IERC20Caller.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 (_IERC20 *IERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { | |
| return _IERC20.Contract.IERC20Transactor.contract.Transfer(opts) | |
| } | |
| // Transact invokes the (paid) contract method with params as input values. | |
| func (_IERC20 *IERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { | |
| return _IERC20.Contract.IERC20Transactor.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 (_IERC20 *IERC20CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { | |
| return _IERC20.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 (_IERC20 *IERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { | |
| return _IERC20.Contract.contract.Transfer(opts) | |
| } | |
| // Transact invokes the (paid) contract method with params as input values. | |
| func (_IERC20 *IERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { | |
| return _IERC20.Contract.contract.Transact(opts, method, params...) | |
| } | |
| // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. | |
| // | |
| // Solidity: function allowance(address owner, address spender) view returns(uint256) | |
| func (_IERC20 *IERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { | |
| var out []interface{} | |
| err := _IERC20.contract.Call(opts, &out, "allowance", owner, spender) | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. | |
| // | |
| // Solidity: function allowance(address owner, address spender) view returns(uint256) | |
| func (_IERC20 *IERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { | |
| return _IERC20.Contract.Allowance(&_IERC20.CallOpts, owner, spender) | |
| } | |
| // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. | |
| // | |
| // Solidity: function allowance(address owner, address spender) view returns(uint256) | |
| func (_IERC20 *IERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { | |
| return _IERC20.Contract.Allowance(&_IERC20.CallOpts, owner, spender) | |
| } | |
| // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. | |
| // | |
| // Solidity: function balanceOf(address owner) view returns(uint256) | |
| func (_IERC20 *IERC20Caller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error) { | |
| var out []interface{} | |
| err := _IERC20.contract.Call(opts, &out, "balanceOf", owner) | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. | |
| // | |
| // Solidity: function balanceOf(address owner) view returns(uint256) | |
| func (_IERC20 *IERC20Session) BalanceOf(owner common.Address) (*big.Int, error) { | |
| return _IERC20.Contract.BalanceOf(&_IERC20.CallOpts, owner) | |
| } | |
| // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. | |
| // | |
| // Solidity: function balanceOf(address owner) view returns(uint256) | |
| func (_IERC20 *IERC20CallerSession) BalanceOf(owner common.Address) (*big.Int, error) { | |
| return _IERC20.Contract.BalanceOf(&_IERC20.CallOpts, owner) | |
| } | |
| // Decimals is a free data retrieval call binding the contract method 0x313ce567. | |
| // | |
| // Solidity: function decimals() view returns(uint8) | |
| func (_IERC20 *IERC20Caller) Decimals(opts *bind.CallOpts) (uint8, error) { | |
| var out []interface{} | |
| err := _IERC20.contract.Call(opts, &out, "decimals") | |
| if err != nil { | |
| return *new(uint8), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) | |
| return out0, err | |
| } | |
| // Decimals is a free data retrieval call binding the contract method 0x313ce567. | |
| // | |
| // Solidity: function decimals() view returns(uint8) | |
| func (_IERC20 *IERC20Session) Decimals() (uint8, error) { | |
| return _IERC20.Contract.Decimals(&_IERC20.CallOpts) | |
| } | |
| // Decimals is a free data retrieval call binding the contract method 0x313ce567. | |
| // | |
| // Solidity: function decimals() view returns(uint8) | |
| func (_IERC20 *IERC20CallerSession) Decimals() (uint8, error) { | |
| return _IERC20.Contract.Decimals(&_IERC20.CallOpts) | |
| } | |
| // Name is a free data retrieval call binding the contract method 0x06fdde03. | |
| // | |
| // Solidity: function name() view returns(string) | |
| func (_IERC20 *IERC20Caller) Name(opts *bind.CallOpts) (string, error) { | |
| var out []interface{} | |
| err := _IERC20.contract.Call(opts, &out, "name") | |
| if err != nil { | |
| return *new(string), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(string)).(*string) | |
| return out0, err | |
| } | |
| // Name is a free data retrieval call binding the contract method 0x06fdde03. | |
| // | |
| // Solidity: function name() view returns(string) | |
| func (_IERC20 *IERC20Session) Name() (string, error) { | |
| return _IERC20.Contract.Name(&_IERC20.CallOpts) | |
| } | |
| // Name is a free data retrieval call binding the contract method 0x06fdde03. | |
| // | |
| // Solidity: function name() view returns(string) | |
| func (_IERC20 *IERC20CallerSession) Name() (string, error) { | |
| return _IERC20.Contract.Name(&_IERC20.CallOpts) | |
| } | |
| // Symbol is a free data retrieval call binding the contract method 0x95d89b41. | |
| // | |
| // Solidity: function symbol() view returns(string) | |
| func (_IERC20 *IERC20Caller) Symbol(opts *bind.CallOpts) (string, error) { | |
| var out []interface{} | |
| err := _IERC20.contract.Call(opts, &out, "symbol") | |
| if err != nil { | |
| return *new(string), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(string)).(*string) | |
| return out0, err | |
| } | |
| // Symbol is a free data retrieval call binding the contract method 0x95d89b41. | |
| // | |
| // Solidity: function symbol() view returns(string) | |
| func (_IERC20 *IERC20Session) Symbol() (string, error) { | |
| return _IERC20.Contract.Symbol(&_IERC20.CallOpts) | |
| } | |
| // Symbol is a free data retrieval call binding the contract method 0x95d89b41. | |
| // | |
| // Solidity: function symbol() view returns(string) | |
| func (_IERC20 *IERC20CallerSession) Symbol() (string, error) { | |
| return _IERC20.Contract.Symbol(&_IERC20.CallOpts) | |
| } | |
| // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. | |
| // | |
| // Solidity: function totalSupply() view returns(uint256) | |
| func (_IERC20 *IERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { | |
| var out []interface{} | |
| err := _IERC20.contract.Call(opts, &out, "totalSupply") | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. | |
| // | |
| // Solidity: function totalSupply() view returns(uint256) | |
| func (_IERC20 *IERC20Session) TotalSupply() (*big.Int, error) { | |
| return _IERC20.Contract.TotalSupply(&_IERC20.CallOpts) | |
| } | |
| // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. | |
| // | |
| // Solidity: function totalSupply() view returns(uint256) | |
| func (_IERC20 *IERC20CallerSession) TotalSupply() (*big.Int, error) { | |
| return _IERC20.Contract.TotalSupply(&_IERC20.CallOpts) | |
| } | |
| // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. | |
| // | |
| // Solidity: function approve(address spender, uint256 value) returns(bool) | |
| func (_IERC20 *IERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IERC20.contract.Transact(opts, "approve", spender, value) | |
| } | |
| // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. | |
| // | |
| // Solidity: function approve(address spender, uint256 value) returns(bool) | |
| func (_IERC20 *IERC20Session) Approve(spender common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IERC20.Contract.Approve(&_IERC20.TransactOpts, spender, value) | |
| } | |
| // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. | |
| // | |
| // Solidity: function approve(address spender, uint256 value) returns(bool) | |
| func (_IERC20 *IERC20TransactorSession) Approve(spender common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IERC20.Contract.Approve(&_IERC20.TransactOpts, spender, value) | |
| } | |
| // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. | |
| // | |
| // Solidity: function transfer(address to, uint256 value) returns(bool) | |
| func (_IERC20 *IERC20Transactor) Transfer(opts *bind.TransactOpts, to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IERC20.contract.Transact(opts, "transfer", to, value) | |
| } | |
| // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. | |
| // | |
| // Solidity: function transfer(address to, uint256 value) returns(bool) | |
| func (_IERC20 *IERC20Session) Transfer(to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IERC20.Contract.Transfer(&_IERC20.TransactOpts, to, value) | |
| } | |
| // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. | |
| // | |
| // Solidity: function transfer(address to, uint256 value) returns(bool) | |
| func (_IERC20 *IERC20TransactorSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IERC20.Contract.Transfer(&_IERC20.TransactOpts, to, value) | |
| } | |
| // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. | |
| // | |
| // Solidity: function transferFrom(address from, address to, uint256 value) returns(bool) | |
| func (_IERC20 *IERC20Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IERC20.contract.Transact(opts, "transferFrom", from, to, value) | |
| } | |
| // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. | |
| // | |
| // Solidity: function transferFrom(address from, address to, uint256 value) returns(bool) | |
| func (_IERC20 *IERC20Session) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IERC20.Contract.TransferFrom(&_IERC20.TransactOpts, from, to, value) | |
| } | |
| // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. | |
| // | |
| // Solidity: function transferFrom(address from, address to, uint256 value) returns(bool) | |
| func (_IERC20 *IERC20TransactorSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IERC20.Contract.TransferFrom(&_IERC20.TransactOpts, from, to, value) | |
| } | |
| // IERC20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the IERC20 contract. | |
| type IERC20ApprovalIterator struct { | |
| Event *IERC20Approval // 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 *IERC20ApprovalIterator) 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(IERC20Approval) | |
| 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(IERC20Approval) | |
| 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 *IERC20ApprovalIterator) Error() error { | |
| return it.fail | |
| } | |
| // Close terminates the iteration process, releasing any pending underlying | |
| // resources. | |
| func (it *IERC20ApprovalIterator) Close() error { | |
| it.sub.Unsubscribe() | |
| return nil | |
| } | |
| // IERC20Approval represents a Approval event raised by the IERC20 contract. | |
| type IERC20Approval struct { | |
| Owner common.Address | |
| Spender common.Address | |
| Value *big.Int | |
| Raw types.Log // Blockchain specific contextual infos | |
| } | |
| // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. | |
| // | |
| // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) | |
| func (_IERC20 *IERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*IERC20ApprovalIterator, error) { | |
| var ownerRule []interface{} | |
| for _, ownerItem := range owner { | |
| ownerRule = append(ownerRule, ownerItem) | |
| } | |
| var spenderRule []interface{} | |
| for _, spenderItem := range spender { | |
| spenderRule = append(spenderRule, spenderItem) | |
| } | |
| logs, sub, err := _IERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IERC20ApprovalIterator{contract: _IERC20.contract, event: "Approval", logs: logs, sub: sub}, nil | |
| } | |
| // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. | |
| // | |
| // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) | |
| func (_IERC20 *IERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) { | |
| var ownerRule []interface{} | |
| for _, ownerItem := range owner { | |
| ownerRule = append(ownerRule, ownerItem) | |
| } | |
| var spenderRule []interface{} | |
| for _, spenderItem := range spender { | |
| spenderRule = append(spenderRule, spenderItem) | |
| } | |
| logs, sub, err := _IERC20.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) | |
| 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(IERC20Approval) | |
| if err := _IERC20.contract.UnpackLog(event, "Approval", 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 | |
| } | |
| // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. | |
| // | |
| // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) | |
| func (_IERC20 *IERC20Filterer) ParseApproval(log types.Log) (*IERC20Approval, error) { | |
| event := new(IERC20Approval) | |
| if err := _IERC20.contract.UnpackLog(event, "Approval", log); err != nil { | |
| return nil, err | |
| } | |
| return event, nil | |
| } | |
| // IERC20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the IERC20 contract. | |
| type IERC20TransferIterator struct { | |
| Event *IERC20Transfer // 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 *IERC20TransferIterator) 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(IERC20Transfer) | |
| 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(IERC20Transfer) | |
| 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 *IERC20TransferIterator) Error() error { | |
| return it.fail | |
| } | |
| // Close terminates the iteration process, releasing any pending underlying | |
| // resources. | |
| func (it *IERC20TransferIterator) Close() error { | |
| it.sub.Unsubscribe() | |
| return nil | |
| } | |
| // IERC20Transfer represents a Transfer event raised by the IERC20 contract. | |
| type IERC20Transfer struct { | |
| From common.Address | |
| To common.Address | |
| Value *big.Int | |
| Raw types.Log // Blockchain specific contextual infos | |
| } | |
| // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. | |
| // | |
| // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) | |
| func (_IERC20 *IERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*IERC20TransferIterator, error) { | |
| var fromRule []interface{} | |
| for _, fromItem := range from { | |
| fromRule = append(fromRule, fromItem) | |
| } | |
| var toRule []interface{} | |
| for _, toItem := range to { | |
| toRule = append(toRule, toItem) | |
| } | |
| logs, sub, err := _IERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IERC20TransferIterator{contract: _IERC20.contract, event: "Transfer", logs: logs, sub: sub}, nil | |
| } | |
| // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. | |
| // | |
| // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) | |
| func (_IERC20 *IERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) { | |
| var fromRule []interface{} | |
| for _, fromItem := range from { | |
| fromRule = append(fromRule, fromItem) | |
| } | |
| var toRule []interface{} | |
| for _, toItem := range to { | |
| toRule = append(toRule, toItem) | |
| } | |
| logs, sub, err := _IERC20.contract.WatchLogs(opts, "Transfer", fromRule, toRule) | |
| 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(IERC20Transfer) | |
| if err := _IERC20.contract.UnpackLog(event, "Transfer", 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 | |
| } | |
| // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. | |
| // | |
| // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) | |
| func (_IERC20 *IERC20Filterer) ParseTransfer(log types.Log) (*IERC20Transfer, error) { | |
| event := new(IERC20Transfer) | |
| if err := _IERC20.contract.UnpackLog(event, "Transfer", log); err != nil { | |
| return nil, err | |
| } | |
| return event, nil | |
| } | |
| // IUniswapV2CalleeABI is the input ABI used to generate the binding from. | |
| const IUniswapV2CalleeABI = "[{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"uniswapV2Call\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" | |
| // IUniswapV2CalleeFuncSigs maps the 4-byte function signature to its string representation. | |
| var IUniswapV2CalleeFuncSigs = map[string]string{ | |
| "10d1e85c": "uniswapV2Call(address,uint256,uint256,bytes)", | |
| } | |
| // IUniswapV2Callee is an auto generated Go binding around an Ethereum contract. | |
| type IUniswapV2Callee struct { | |
| IUniswapV2CalleeCaller // Read-only binding to the contract | |
| IUniswapV2CalleeTransactor // Write-only binding to the contract | |
| IUniswapV2CalleeFilterer // Log filterer for contract events | |
| } | |
| // IUniswapV2CalleeCaller is an auto generated read-only Go binding around an Ethereum contract. | |
| type IUniswapV2CalleeCaller struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // IUniswapV2CalleeTransactor is an auto generated write-only Go binding around an Ethereum contract. | |
| type IUniswapV2CalleeTransactor struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // IUniswapV2CalleeFilterer is an auto generated log filtering Go binding around an Ethereum contract events. | |
| type IUniswapV2CalleeFilterer struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // IUniswapV2CalleeSession is an auto generated Go binding around an Ethereum contract, | |
| // with pre-set call and transact options. | |
| type IUniswapV2CalleeSession struct { | |
| Contract *IUniswapV2Callee // 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 | |
| } | |
| // IUniswapV2CalleeCallerSession is an auto generated read-only Go binding around an Ethereum contract, | |
| // with pre-set call options. | |
| type IUniswapV2CalleeCallerSession struct { | |
| Contract *IUniswapV2CalleeCaller // Generic contract caller binding to set the session for | |
| CallOpts bind.CallOpts // Call options to use throughout this session | |
| } | |
| // IUniswapV2CalleeTransactorSession is an auto generated write-only Go binding around an Ethereum contract, | |
| // with pre-set transact options. | |
| type IUniswapV2CalleeTransactorSession struct { | |
| Contract *IUniswapV2CalleeTransactor // Generic contract transactor binding to set the session for | |
| TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session | |
| } | |
| // IUniswapV2CalleeRaw is an auto generated low-level Go binding around an Ethereum contract. | |
| type IUniswapV2CalleeRaw struct { | |
| Contract *IUniswapV2Callee // Generic contract binding to access the raw methods on | |
| } | |
| // IUniswapV2CalleeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. | |
| type IUniswapV2CalleeCallerRaw struct { | |
| Contract *IUniswapV2CalleeCaller // Generic read-only contract binding to access the raw methods on | |
| } | |
| // IUniswapV2CalleeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. | |
| type IUniswapV2CalleeTransactorRaw struct { | |
| Contract *IUniswapV2CalleeTransactor // Generic write-only contract binding to access the raw methods on | |
| } | |
| // NewIUniswapV2Callee creates a new instance of IUniswapV2Callee, bound to a specific deployed contract. | |
| func NewIUniswapV2Callee(address common.Address, backend bind.ContractBackend) (*IUniswapV2Callee, error) { | |
| contract, err := bindIUniswapV2Callee(address, backend, backend, backend) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2Callee{IUniswapV2CalleeCaller: IUniswapV2CalleeCaller{contract: contract}, IUniswapV2CalleeTransactor: IUniswapV2CalleeTransactor{contract: contract}, IUniswapV2CalleeFilterer: IUniswapV2CalleeFilterer{contract: contract}}, nil | |
| } | |
| // NewIUniswapV2CalleeCaller creates a new read-only instance of IUniswapV2Callee, bound to a specific deployed contract. | |
| func NewIUniswapV2CalleeCaller(address common.Address, caller bind.ContractCaller) (*IUniswapV2CalleeCaller, error) { | |
| contract, err := bindIUniswapV2Callee(address, caller, nil, nil) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2CalleeCaller{contract: contract}, nil | |
| } | |
| // NewIUniswapV2CalleeTransactor creates a new write-only instance of IUniswapV2Callee, bound to a specific deployed contract. | |
| func NewIUniswapV2CalleeTransactor(address common.Address, transactor bind.ContractTransactor) (*IUniswapV2CalleeTransactor, error) { | |
| contract, err := bindIUniswapV2Callee(address, nil, transactor, nil) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2CalleeTransactor{contract: contract}, nil | |
| } | |
| // NewIUniswapV2CalleeFilterer creates a new log filterer instance of IUniswapV2Callee, bound to a specific deployed contract. | |
| func NewIUniswapV2CalleeFilterer(address common.Address, filterer bind.ContractFilterer) (*IUniswapV2CalleeFilterer, error) { | |
| contract, err := bindIUniswapV2Callee(address, nil, nil, filterer) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2CalleeFilterer{contract: contract}, nil | |
| } | |
| // bindIUniswapV2Callee binds a generic wrapper to an already deployed contract. | |
| func bindIUniswapV2Callee(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { | |
| parsed, err := abi.JSON(strings.NewReader(IUniswapV2CalleeABI)) | |
| 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 (_IUniswapV2Callee *IUniswapV2CalleeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { | |
| return _IUniswapV2Callee.Contract.IUniswapV2CalleeCaller.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 (_IUniswapV2Callee *IUniswapV2CalleeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { | |
| return _IUniswapV2Callee.Contract.IUniswapV2CalleeTransactor.contract.Transfer(opts) | |
| } | |
| // Transact invokes the (paid) contract method with params as input values. | |
| func (_IUniswapV2Callee *IUniswapV2CalleeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { | |
| return _IUniswapV2Callee.Contract.IUniswapV2CalleeTransactor.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 (_IUniswapV2Callee *IUniswapV2CalleeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { | |
| return _IUniswapV2Callee.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 (_IUniswapV2Callee *IUniswapV2CalleeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { | |
| return _IUniswapV2Callee.Contract.contract.Transfer(opts) | |
| } | |
| // Transact invokes the (paid) contract method with params as input values. | |
| func (_IUniswapV2Callee *IUniswapV2CalleeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { | |
| return _IUniswapV2Callee.Contract.contract.Transact(opts, method, params...) | |
| } | |
| // UniswapV2Call is a paid mutator transaction binding the contract method 0x10d1e85c. | |
| // | |
| // Solidity: function uniswapV2Call(address sender, uint256 amount0, uint256 amount1, bytes data) returns() | |
| func (_IUniswapV2Callee *IUniswapV2CalleeTransactor) UniswapV2Call(opts *bind.TransactOpts, sender common.Address, amount0 *big.Int, amount1 *big.Int, data []byte) (*types.Transaction, error) { | |
| return _IUniswapV2Callee.contract.Transact(opts, "uniswapV2Call", sender, amount0, amount1, data) | |
| } | |
| // UniswapV2Call is a paid mutator transaction binding the contract method 0x10d1e85c. | |
| // | |
| // Solidity: function uniswapV2Call(address sender, uint256 amount0, uint256 amount1, bytes data) returns() | |
| func (_IUniswapV2Callee *IUniswapV2CalleeSession) UniswapV2Call(sender common.Address, amount0 *big.Int, amount1 *big.Int, data []byte) (*types.Transaction, error) { | |
| return _IUniswapV2Callee.Contract.UniswapV2Call(&_IUniswapV2Callee.TransactOpts, sender, amount0, amount1, data) | |
| } | |
| // UniswapV2Call is a paid mutator transaction binding the contract method 0x10d1e85c. | |
| // | |
| // Solidity: function uniswapV2Call(address sender, uint256 amount0, uint256 amount1, bytes data) returns() | |
| func (_IUniswapV2Callee *IUniswapV2CalleeTransactorSession) UniswapV2Call(sender common.Address, amount0 *big.Int, amount1 *big.Int, data []byte) (*types.Transaction, error) { | |
| return _IUniswapV2Callee.Contract.UniswapV2Call(&_IUniswapV2Callee.TransactOpts, sender, amount0, amount1, data) | |
| } | |
| // IUniswapV2ERC20ABI is the input ABI used to generate the binding from. | |
| const IUniswapV2ERC20ABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[],\"name\":\"DOMAIN_SEPARATOR\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"PERMIT_TYPEHASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"nonces\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"permit\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" | |
| // IUniswapV2ERC20FuncSigs maps the 4-byte function signature to its string representation. | |
| var IUniswapV2ERC20FuncSigs = map[string]string{ | |
| "3644e515": "DOMAIN_SEPARATOR()", | |
| "30adf81f": "PERMIT_TYPEHASH()", | |
| "dd62ed3e": "allowance(address,address)", | |
| "095ea7b3": "approve(address,uint256)", | |
| "70a08231": "balanceOf(address)", | |
| "313ce567": "decimals()", | |
| "06fdde03": "name()", | |
| "7ecebe00": "nonces(address)", | |
| "d505accf": "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)", | |
| "95d89b41": "symbol()", | |
| "18160ddd": "totalSupply()", | |
| "a9059cbb": "transfer(address,uint256)", | |
| "23b872dd": "transferFrom(address,address,uint256)", | |
| } | |
| // IUniswapV2ERC20 is an auto generated Go binding around an Ethereum contract. | |
| type IUniswapV2ERC20 struct { | |
| IUniswapV2ERC20Caller // Read-only binding to the contract | |
| IUniswapV2ERC20Transactor // Write-only binding to the contract | |
| IUniswapV2ERC20Filterer // Log filterer for contract events | |
| } | |
| // IUniswapV2ERC20Caller is an auto generated read-only Go binding around an Ethereum contract. | |
| type IUniswapV2ERC20Caller struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // IUniswapV2ERC20Transactor is an auto generated write-only Go binding around an Ethereum contract. | |
| type IUniswapV2ERC20Transactor struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // IUniswapV2ERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. | |
| type IUniswapV2ERC20Filterer struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // IUniswapV2ERC20Session is an auto generated Go binding around an Ethereum contract, | |
| // with pre-set call and transact options. | |
| type IUniswapV2ERC20Session struct { | |
| Contract *IUniswapV2ERC20 // 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 | |
| } | |
| // IUniswapV2ERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract, | |
| // with pre-set call options. | |
| type IUniswapV2ERC20CallerSession struct { | |
| Contract *IUniswapV2ERC20Caller // Generic contract caller binding to set the session for | |
| CallOpts bind.CallOpts // Call options to use throughout this session | |
| } | |
| // IUniswapV2ERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, | |
| // with pre-set transact options. | |
| type IUniswapV2ERC20TransactorSession struct { | |
| Contract *IUniswapV2ERC20Transactor // Generic contract transactor binding to set the session for | |
| TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session | |
| } | |
| // IUniswapV2ERC20Raw is an auto generated low-level Go binding around an Ethereum contract. | |
| type IUniswapV2ERC20Raw struct { | |
| Contract *IUniswapV2ERC20 // Generic contract binding to access the raw methods on | |
| } | |
| // IUniswapV2ERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. | |
| type IUniswapV2ERC20CallerRaw struct { | |
| Contract *IUniswapV2ERC20Caller // Generic read-only contract binding to access the raw methods on | |
| } | |
| // IUniswapV2ERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. | |
| type IUniswapV2ERC20TransactorRaw struct { | |
| Contract *IUniswapV2ERC20Transactor // Generic write-only contract binding to access the raw methods on | |
| } | |
| // NewIUniswapV2ERC20 creates a new instance of IUniswapV2ERC20, bound to a specific deployed contract. | |
| func NewIUniswapV2ERC20(address common.Address, backend bind.ContractBackend) (*IUniswapV2ERC20, error) { | |
| contract, err := bindIUniswapV2ERC20(address, backend, backend, backend) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2ERC20{IUniswapV2ERC20Caller: IUniswapV2ERC20Caller{contract: contract}, IUniswapV2ERC20Transactor: IUniswapV2ERC20Transactor{contract: contract}, IUniswapV2ERC20Filterer: IUniswapV2ERC20Filterer{contract: contract}}, nil | |
| } | |
| // NewIUniswapV2ERC20Caller creates a new read-only instance of IUniswapV2ERC20, bound to a specific deployed contract. | |
| func NewIUniswapV2ERC20Caller(address common.Address, caller bind.ContractCaller) (*IUniswapV2ERC20Caller, error) { | |
| contract, err := bindIUniswapV2ERC20(address, caller, nil, nil) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2ERC20Caller{contract: contract}, nil | |
| } | |
| // NewIUniswapV2ERC20Transactor creates a new write-only instance of IUniswapV2ERC20, bound to a specific deployed contract. | |
| func NewIUniswapV2ERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*IUniswapV2ERC20Transactor, error) { | |
| contract, err := bindIUniswapV2ERC20(address, nil, transactor, nil) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2ERC20Transactor{contract: contract}, nil | |
| } | |
| // NewIUniswapV2ERC20Filterer creates a new log filterer instance of IUniswapV2ERC20, bound to a specific deployed contract. | |
| func NewIUniswapV2ERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*IUniswapV2ERC20Filterer, error) { | |
| contract, err := bindIUniswapV2ERC20(address, nil, nil, filterer) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2ERC20Filterer{contract: contract}, nil | |
| } | |
| // bindIUniswapV2ERC20 binds a generic wrapper to an already deployed contract. | |
| func bindIUniswapV2ERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { | |
| parsed, err := abi.JSON(strings.NewReader(IUniswapV2ERC20ABI)) | |
| 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 (_IUniswapV2ERC20 *IUniswapV2ERC20Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { | |
| return _IUniswapV2ERC20.Contract.IUniswapV2ERC20Caller.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 (_IUniswapV2ERC20 *IUniswapV2ERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { | |
| return _IUniswapV2ERC20.Contract.IUniswapV2ERC20Transactor.contract.Transfer(opts) | |
| } | |
| // Transact invokes the (paid) contract method with params as input values. | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { | |
| return _IUniswapV2ERC20.Contract.IUniswapV2ERC20Transactor.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 (_IUniswapV2ERC20 *IUniswapV2ERC20CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { | |
| return _IUniswapV2ERC20.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 (_IUniswapV2ERC20 *IUniswapV2ERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { | |
| return _IUniswapV2ERC20.Contract.contract.Transfer(opts) | |
| } | |
| // Transact invokes the (paid) contract method with params as input values. | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { | |
| return _IUniswapV2ERC20.Contract.contract.Transact(opts, method, params...) | |
| } | |
| // DOMAINSEPARATOR is a free data retrieval call binding the contract method 0x3644e515. | |
| // | |
| // Solidity: function DOMAIN_SEPARATOR() view returns(bytes32) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Caller) DOMAINSEPARATOR(opts *bind.CallOpts) ([32]byte, error) { | |
| var out []interface{} | |
| err := _IUniswapV2ERC20.contract.Call(opts, &out, "DOMAIN_SEPARATOR") | |
| if err != nil { | |
| return *new([32]byte), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) | |
| return out0, err | |
| } | |
| // DOMAINSEPARATOR is a free data retrieval call binding the contract method 0x3644e515. | |
| // | |
| // Solidity: function DOMAIN_SEPARATOR() view returns(bytes32) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Session) DOMAINSEPARATOR() ([32]byte, error) { | |
| return _IUniswapV2ERC20.Contract.DOMAINSEPARATOR(&_IUniswapV2ERC20.CallOpts) | |
| } | |
| // DOMAINSEPARATOR is a free data retrieval call binding the contract method 0x3644e515. | |
| // | |
| // Solidity: function DOMAIN_SEPARATOR() view returns(bytes32) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20CallerSession) DOMAINSEPARATOR() ([32]byte, error) { | |
| return _IUniswapV2ERC20.Contract.DOMAINSEPARATOR(&_IUniswapV2ERC20.CallOpts) | |
| } | |
| // PERMITTYPEHASH is a free data retrieval call binding the contract method 0x30adf81f. | |
| // | |
| // Solidity: function PERMIT_TYPEHASH() pure returns(bytes32) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Caller) PERMITTYPEHASH(opts *bind.CallOpts) ([32]byte, error) { | |
| var out []interface{} | |
| err := _IUniswapV2ERC20.contract.Call(opts, &out, "PERMIT_TYPEHASH") | |
| if err != nil { | |
| return *new([32]byte), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) | |
| return out0, err | |
| } | |
| // PERMITTYPEHASH is a free data retrieval call binding the contract method 0x30adf81f. | |
| // | |
| // Solidity: function PERMIT_TYPEHASH() pure returns(bytes32) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Session) PERMITTYPEHASH() ([32]byte, error) { | |
| return _IUniswapV2ERC20.Contract.PERMITTYPEHASH(&_IUniswapV2ERC20.CallOpts) | |
| } | |
| // PERMITTYPEHASH is a free data retrieval call binding the contract method 0x30adf81f. | |
| // | |
| // Solidity: function PERMIT_TYPEHASH() pure returns(bytes32) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20CallerSession) PERMITTYPEHASH() ([32]byte, error) { | |
| return _IUniswapV2ERC20.Contract.PERMITTYPEHASH(&_IUniswapV2ERC20.CallOpts) | |
| } | |
| // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. | |
| // | |
| // Solidity: function allowance(address owner, address spender) view returns(uint256) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { | |
| var out []interface{} | |
| err := _IUniswapV2ERC20.contract.Call(opts, &out, "allowance", owner, spender) | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. | |
| // | |
| // Solidity: function allowance(address owner, address spender) view returns(uint256) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { | |
| return _IUniswapV2ERC20.Contract.Allowance(&_IUniswapV2ERC20.CallOpts, owner, spender) | |
| } | |
| // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. | |
| // | |
| // Solidity: function allowance(address owner, address spender) view returns(uint256) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { | |
| return _IUniswapV2ERC20.Contract.Allowance(&_IUniswapV2ERC20.CallOpts, owner, spender) | |
| } | |
| // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. | |
| // | |
| // Solidity: function balanceOf(address owner) view returns(uint256) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Caller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error) { | |
| var out []interface{} | |
| err := _IUniswapV2ERC20.contract.Call(opts, &out, "balanceOf", owner) | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. | |
| // | |
| // Solidity: function balanceOf(address owner) view returns(uint256) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Session) BalanceOf(owner common.Address) (*big.Int, error) { | |
| return _IUniswapV2ERC20.Contract.BalanceOf(&_IUniswapV2ERC20.CallOpts, owner) | |
| } | |
| // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. | |
| // | |
| // Solidity: function balanceOf(address owner) view returns(uint256) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20CallerSession) BalanceOf(owner common.Address) (*big.Int, error) { | |
| return _IUniswapV2ERC20.Contract.BalanceOf(&_IUniswapV2ERC20.CallOpts, owner) | |
| } | |
| // Decimals is a free data retrieval call binding the contract method 0x313ce567. | |
| // | |
| // Solidity: function decimals() pure returns(uint8) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Caller) Decimals(opts *bind.CallOpts) (uint8, error) { | |
| var out []interface{} | |
| err := _IUniswapV2ERC20.contract.Call(opts, &out, "decimals") | |
| if err != nil { | |
| return *new(uint8), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) | |
| return out0, err | |
| } | |
| // Decimals is a free data retrieval call binding the contract method 0x313ce567. | |
| // | |
| // Solidity: function decimals() pure returns(uint8) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Session) Decimals() (uint8, error) { | |
| return _IUniswapV2ERC20.Contract.Decimals(&_IUniswapV2ERC20.CallOpts) | |
| } | |
| // Decimals is a free data retrieval call binding the contract method 0x313ce567. | |
| // | |
| // Solidity: function decimals() pure returns(uint8) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20CallerSession) Decimals() (uint8, error) { | |
| return _IUniswapV2ERC20.Contract.Decimals(&_IUniswapV2ERC20.CallOpts) | |
| } | |
| // Name is a free data retrieval call binding the contract method 0x06fdde03. | |
| // | |
| // Solidity: function name() pure returns(string) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Caller) Name(opts *bind.CallOpts) (string, error) { | |
| var out []interface{} | |
| err := _IUniswapV2ERC20.contract.Call(opts, &out, "name") | |
| if err != nil { | |
| return *new(string), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(string)).(*string) | |
| return out0, err | |
| } | |
| // Name is a free data retrieval call binding the contract method 0x06fdde03. | |
| // | |
| // Solidity: function name() pure returns(string) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Session) Name() (string, error) { | |
| return _IUniswapV2ERC20.Contract.Name(&_IUniswapV2ERC20.CallOpts) | |
| } | |
| // Name is a free data retrieval call binding the contract method 0x06fdde03. | |
| // | |
| // Solidity: function name() pure returns(string) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20CallerSession) Name() (string, error) { | |
| return _IUniswapV2ERC20.Contract.Name(&_IUniswapV2ERC20.CallOpts) | |
| } | |
| // Nonces is a free data retrieval call binding the contract method 0x7ecebe00. | |
| // | |
| // Solidity: function nonces(address owner) view returns(uint256) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Caller) Nonces(opts *bind.CallOpts, owner common.Address) (*big.Int, error) { | |
| var out []interface{} | |
| err := _IUniswapV2ERC20.contract.Call(opts, &out, "nonces", owner) | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // Nonces is a free data retrieval call binding the contract method 0x7ecebe00. | |
| // | |
| // Solidity: function nonces(address owner) view returns(uint256) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Session) Nonces(owner common.Address) (*big.Int, error) { | |
| return _IUniswapV2ERC20.Contract.Nonces(&_IUniswapV2ERC20.CallOpts, owner) | |
| } | |
| // Nonces is a free data retrieval call binding the contract method 0x7ecebe00. | |
| // | |
| // Solidity: function nonces(address owner) view returns(uint256) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20CallerSession) Nonces(owner common.Address) (*big.Int, error) { | |
| return _IUniswapV2ERC20.Contract.Nonces(&_IUniswapV2ERC20.CallOpts, owner) | |
| } | |
| // Symbol is a free data retrieval call binding the contract method 0x95d89b41. | |
| // | |
| // Solidity: function symbol() pure returns(string) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Caller) Symbol(opts *bind.CallOpts) (string, error) { | |
| var out []interface{} | |
| err := _IUniswapV2ERC20.contract.Call(opts, &out, "symbol") | |
| if err != nil { | |
| return *new(string), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(string)).(*string) | |
| return out0, err | |
| } | |
| // Symbol is a free data retrieval call binding the contract method 0x95d89b41. | |
| // | |
| // Solidity: function symbol() pure returns(string) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Session) Symbol() (string, error) { | |
| return _IUniswapV2ERC20.Contract.Symbol(&_IUniswapV2ERC20.CallOpts) | |
| } | |
| // Symbol is a free data retrieval call binding the contract method 0x95d89b41. | |
| // | |
| // Solidity: function symbol() pure returns(string) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20CallerSession) Symbol() (string, error) { | |
| return _IUniswapV2ERC20.Contract.Symbol(&_IUniswapV2ERC20.CallOpts) | |
| } | |
| // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. | |
| // | |
| // Solidity: function totalSupply() view returns(uint256) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { | |
| var out []interface{} | |
| err := _IUniswapV2ERC20.contract.Call(opts, &out, "totalSupply") | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. | |
| // | |
| // Solidity: function totalSupply() view returns(uint256) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Session) TotalSupply() (*big.Int, error) { | |
| return _IUniswapV2ERC20.Contract.TotalSupply(&_IUniswapV2ERC20.CallOpts) | |
| } | |
| // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. | |
| // | |
| // Solidity: function totalSupply() view returns(uint256) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20CallerSession) TotalSupply() (*big.Int, error) { | |
| return _IUniswapV2ERC20.Contract.TotalSupply(&_IUniswapV2ERC20.CallOpts) | |
| } | |
| // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. | |
| // | |
| // Solidity: function approve(address spender, uint256 value) returns(bool) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IUniswapV2ERC20.contract.Transact(opts, "approve", spender, value) | |
| } | |
| // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. | |
| // | |
| // Solidity: function approve(address spender, uint256 value) returns(bool) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Session) Approve(spender common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IUniswapV2ERC20.Contract.Approve(&_IUniswapV2ERC20.TransactOpts, spender, value) | |
| } | |
| // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. | |
| // | |
| // Solidity: function approve(address spender, uint256 value) returns(bool) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20TransactorSession) Approve(spender common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IUniswapV2ERC20.Contract.Approve(&_IUniswapV2ERC20.TransactOpts, spender, value) | |
| } | |
| // Permit is a paid mutator transaction binding the contract method 0xd505accf. | |
| // | |
| // Solidity: function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) returns() | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Transactor) Permit(opts *bind.TransactOpts, owner common.Address, spender common.Address, value *big.Int, deadline *big.Int, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) { | |
| return _IUniswapV2ERC20.contract.Transact(opts, "permit", owner, spender, value, deadline, v, r, s) | |
| } | |
| // Permit is a paid mutator transaction binding the contract method 0xd505accf. | |
| // | |
| // Solidity: function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) returns() | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Session) Permit(owner common.Address, spender common.Address, value *big.Int, deadline *big.Int, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) { | |
| return _IUniswapV2ERC20.Contract.Permit(&_IUniswapV2ERC20.TransactOpts, owner, spender, value, deadline, v, r, s) | |
| } | |
| // Permit is a paid mutator transaction binding the contract method 0xd505accf. | |
| // | |
| // Solidity: function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) returns() | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20TransactorSession) Permit(owner common.Address, spender common.Address, value *big.Int, deadline *big.Int, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) { | |
| return _IUniswapV2ERC20.Contract.Permit(&_IUniswapV2ERC20.TransactOpts, owner, spender, value, deadline, v, r, s) | |
| } | |
| // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. | |
| // | |
| // Solidity: function transfer(address to, uint256 value) returns(bool) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Transactor) Transfer(opts *bind.TransactOpts, to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IUniswapV2ERC20.contract.Transact(opts, "transfer", to, value) | |
| } | |
| // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. | |
| // | |
| // Solidity: function transfer(address to, uint256 value) returns(bool) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Session) Transfer(to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IUniswapV2ERC20.Contract.Transfer(&_IUniswapV2ERC20.TransactOpts, to, value) | |
| } | |
| // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. | |
| // | |
| // Solidity: function transfer(address to, uint256 value) returns(bool) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20TransactorSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IUniswapV2ERC20.Contract.Transfer(&_IUniswapV2ERC20.TransactOpts, to, value) | |
| } | |
| // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. | |
| // | |
| // Solidity: function transferFrom(address from, address to, uint256 value) returns(bool) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IUniswapV2ERC20.contract.Transact(opts, "transferFrom", from, to, value) | |
| } | |
| // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. | |
| // | |
| // Solidity: function transferFrom(address from, address to, uint256 value) returns(bool) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Session) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IUniswapV2ERC20.Contract.TransferFrom(&_IUniswapV2ERC20.TransactOpts, from, to, value) | |
| } | |
| // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. | |
| // | |
| // Solidity: function transferFrom(address from, address to, uint256 value) returns(bool) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20TransactorSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IUniswapV2ERC20.Contract.TransferFrom(&_IUniswapV2ERC20.TransactOpts, from, to, value) | |
| } | |
| // IUniswapV2ERC20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the IUniswapV2ERC20 contract. | |
| type IUniswapV2ERC20ApprovalIterator struct { | |
| Event *IUniswapV2ERC20Approval // 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 *IUniswapV2ERC20ApprovalIterator) 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(IUniswapV2ERC20Approval) | |
| 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(IUniswapV2ERC20Approval) | |
| 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 *IUniswapV2ERC20ApprovalIterator) Error() error { | |
| return it.fail | |
| } | |
| // Close terminates the iteration process, releasing any pending underlying | |
| // resources. | |
| func (it *IUniswapV2ERC20ApprovalIterator) Close() error { | |
| it.sub.Unsubscribe() | |
| return nil | |
| } | |
| // IUniswapV2ERC20Approval represents a Approval event raised by the IUniswapV2ERC20 contract. | |
| type IUniswapV2ERC20Approval struct { | |
| Owner common.Address | |
| Spender common.Address | |
| Value *big.Int | |
| Raw types.Log // Blockchain specific contextual infos | |
| } | |
| // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. | |
| // | |
| // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*IUniswapV2ERC20ApprovalIterator, error) { | |
| var ownerRule []interface{} | |
| for _, ownerItem := range owner { | |
| ownerRule = append(ownerRule, ownerItem) | |
| } | |
| var spenderRule []interface{} | |
| for _, spenderItem := range spender { | |
| spenderRule = append(spenderRule, spenderItem) | |
| } | |
| logs, sub, err := _IUniswapV2ERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2ERC20ApprovalIterator{contract: _IUniswapV2ERC20.contract, event: "Approval", logs: logs, sub: sub}, nil | |
| } | |
| // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. | |
| // | |
| // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IUniswapV2ERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) { | |
| var ownerRule []interface{} | |
| for _, ownerItem := range owner { | |
| ownerRule = append(ownerRule, ownerItem) | |
| } | |
| var spenderRule []interface{} | |
| for _, spenderItem := range spender { | |
| spenderRule = append(spenderRule, spenderItem) | |
| } | |
| logs, sub, err := _IUniswapV2ERC20.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) | |
| 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(IUniswapV2ERC20Approval) | |
| if err := _IUniswapV2ERC20.contract.UnpackLog(event, "Approval", 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 | |
| } | |
| // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. | |
| // | |
| // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Filterer) ParseApproval(log types.Log) (*IUniswapV2ERC20Approval, error) { | |
| event := new(IUniswapV2ERC20Approval) | |
| if err := _IUniswapV2ERC20.contract.UnpackLog(event, "Approval", log); err != nil { | |
| return nil, err | |
| } | |
| return event, nil | |
| } | |
| // IUniswapV2ERC20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the IUniswapV2ERC20 contract. | |
| type IUniswapV2ERC20TransferIterator struct { | |
| Event *IUniswapV2ERC20Transfer // 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 *IUniswapV2ERC20TransferIterator) 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(IUniswapV2ERC20Transfer) | |
| 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(IUniswapV2ERC20Transfer) | |
| 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 *IUniswapV2ERC20TransferIterator) Error() error { | |
| return it.fail | |
| } | |
| // Close terminates the iteration process, releasing any pending underlying | |
| // resources. | |
| func (it *IUniswapV2ERC20TransferIterator) Close() error { | |
| it.sub.Unsubscribe() | |
| return nil | |
| } | |
| // IUniswapV2ERC20Transfer represents a Transfer event raised by the IUniswapV2ERC20 contract. | |
| type IUniswapV2ERC20Transfer struct { | |
| From common.Address | |
| To common.Address | |
| Value *big.Int | |
| Raw types.Log // Blockchain specific contextual infos | |
| } | |
| // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. | |
| // | |
| // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*IUniswapV2ERC20TransferIterator, error) { | |
| var fromRule []interface{} | |
| for _, fromItem := range from { | |
| fromRule = append(fromRule, fromItem) | |
| } | |
| var toRule []interface{} | |
| for _, toItem := range to { | |
| toRule = append(toRule, toItem) | |
| } | |
| logs, sub, err := _IUniswapV2ERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2ERC20TransferIterator{contract: _IUniswapV2ERC20.contract, event: "Transfer", logs: logs, sub: sub}, nil | |
| } | |
| // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. | |
| // | |
| // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IUniswapV2ERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) { | |
| var fromRule []interface{} | |
| for _, fromItem := range from { | |
| fromRule = append(fromRule, fromItem) | |
| } | |
| var toRule []interface{} | |
| for _, toItem := range to { | |
| toRule = append(toRule, toItem) | |
| } | |
| logs, sub, err := _IUniswapV2ERC20.contract.WatchLogs(opts, "Transfer", fromRule, toRule) | |
| 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(IUniswapV2ERC20Transfer) | |
| if err := _IUniswapV2ERC20.contract.UnpackLog(event, "Transfer", 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 | |
| } | |
| // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. | |
| // | |
| // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) | |
| func (_IUniswapV2ERC20 *IUniswapV2ERC20Filterer) ParseTransfer(log types.Log) (*IUniswapV2ERC20Transfer, error) { | |
| event := new(IUniswapV2ERC20Transfer) | |
| if err := _IUniswapV2ERC20.contract.UnpackLog(event, "Transfer", log); err != nil { | |
| return nil, err | |
| } | |
| return event, nil | |
| } | |
| // IUniswapV2FactoryABI is the input ABI used to generate the binding from. | |
| const IUniswapV2FactoryABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token0\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token1\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"pair\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"PairCreated\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"allPairs\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"pair\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"allPairsLength\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenA\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenB\",\"type\":\"address\"}],\"name\":\"createPair\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"pair\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"feeTo\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"feeToSetter\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenA\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenB\",\"type\":\"address\"}],\"name\":\"getPair\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"pair\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"setFeeTo\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"setFeeToSetter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" | |
| // IUniswapV2FactoryFuncSigs maps the 4-byte function signature to its string representation. | |
| var IUniswapV2FactoryFuncSigs = map[string]string{ | |
| "1e3dd18b": "allPairs(uint256)", | |
| "574f2ba3": "allPairsLength()", | |
| "c9c65396": "createPair(address,address)", | |
| "017e7e58": "feeTo()", | |
| "094b7415": "feeToSetter()", | |
| "e6a43905": "getPair(address,address)", | |
| "f46901ed": "setFeeTo(address)", | |
| "a2e74af6": "setFeeToSetter(address)", | |
| } | |
| // IUniswapV2Factory is an auto generated Go binding around an Ethereum contract. | |
| type IUniswapV2Factory struct { | |
| IUniswapV2FactoryCaller // Read-only binding to the contract | |
| IUniswapV2FactoryTransactor // Write-only binding to the contract | |
| IUniswapV2FactoryFilterer // Log filterer for contract events | |
| } | |
| // IUniswapV2FactoryCaller is an auto generated read-only Go binding around an Ethereum contract. | |
| type IUniswapV2FactoryCaller struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // IUniswapV2FactoryTransactor is an auto generated write-only Go binding around an Ethereum contract. | |
| type IUniswapV2FactoryTransactor struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // IUniswapV2FactoryFilterer is an auto generated log filtering Go binding around an Ethereum contract events. | |
| type IUniswapV2FactoryFilterer struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // IUniswapV2FactorySession is an auto generated Go binding around an Ethereum contract, | |
| // with pre-set call and transact options. | |
| type IUniswapV2FactorySession struct { | |
| Contract *IUniswapV2Factory // 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 | |
| } | |
| // IUniswapV2FactoryCallerSession is an auto generated read-only Go binding around an Ethereum contract, | |
| // with pre-set call options. | |
| type IUniswapV2FactoryCallerSession struct { | |
| Contract *IUniswapV2FactoryCaller // Generic contract caller binding to set the session for | |
| CallOpts bind.CallOpts // Call options to use throughout this session | |
| } | |
| // IUniswapV2FactoryTransactorSession is an auto generated write-only Go binding around an Ethereum contract, | |
| // with pre-set transact options. | |
| type IUniswapV2FactoryTransactorSession struct { | |
| Contract *IUniswapV2FactoryTransactor // Generic contract transactor binding to set the session for | |
| TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session | |
| } | |
| // IUniswapV2FactoryRaw is an auto generated low-level Go binding around an Ethereum contract. | |
| type IUniswapV2FactoryRaw struct { | |
| Contract *IUniswapV2Factory // Generic contract binding to access the raw methods on | |
| } | |
| // IUniswapV2FactoryCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. | |
| type IUniswapV2FactoryCallerRaw struct { | |
| Contract *IUniswapV2FactoryCaller // Generic read-only contract binding to access the raw methods on | |
| } | |
| // IUniswapV2FactoryTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. | |
| type IUniswapV2FactoryTransactorRaw struct { | |
| Contract *IUniswapV2FactoryTransactor // Generic write-only contract binding to access the raw methods on | |
| } | |
| // NewIUniswapV2Factory creates a new instance of IUniswapV2Factory, bound to a specific deployed contract. | |
| func NewIUniswapV2Factory(address common.Address, backend bind.ContractBackend) (*IUniswapV2Factory, error) { | |
| contract, err := bindIUniswapV2Factory(address, backend, backend, backend) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2Factory{IUniswapV2FactoryCaller: IUniswapV2FactoryCaller{contract: contract}, IUniswapV2FactoryTransactor: IUniswapV2FactoryTransactor{contract: contract}, IUniswapV2FactoryFilterer: IUniswapV2FactoryFilterer{contract: contract}}, nil | |
| } | |
| // NewIUniswapV2FactoryCaller creates a new read-only instance of IUniswapV2Factory, bound to a specific deployed contract. | |
| func NewIUniswapV2FactoryCaller(address common.Address, caller bind.ContractCaller) (*IUniswapV2FactoryCaller, error) { | |
| contract, err := bindIUniswapV2Factory(address, caller, nil, nil) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2FactoryCaller{contract: contract}, nil | |
| } | |
| // NewIUniswapV2FactoryTransactor creates a new write-only instance of IUniswapV2Factory, bound to a specific deployed contract. | |
| func NewIUniswapV2FactoryTransactor(address common.Address, transactor bind.ContractTransactor) (*IUniswapV2FactoryTransactor, error) { | |
| contract, err := bindIUniswapV2Factory(address, nil, transactor, nil) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2FactoryTransactor{contract: contract}, nil | |
| } | |
| // NewIUniswapV2FactoryFilterer creates a new log filterer instance of IUniswapV2Factory, bound to a specific deployed contract. | |
| func NewIUniswapV2FactoryFilterer(address common.Address, filterer bind.ContractFilterer) (*IUniswapV2FactoryFilterer, error) { | |
| contract, err := bindIUniswapV2Factory(address, nil, nil, filterer) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2FactoryFilterer{contract: contract}, nil | |
| } | |
| // bindIUniswapV2Factory binds a generic wrapper to an already deployed contract. | |
| func bindIUniswapV2Factory(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { | |
| parsed, err := abi.JSON(strings.NewReader(IUniswapV2FactoryABI)) | |
| 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 (_IUniswapV2Factory *IUniswapV2FactoryRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { | |
| return _IUniswapV2Factory.Contract.IUniswapV2FactoryCaller.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 (_IUniswapV2Factory *IUniswapV2FactoryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { | |
| return _IUniswapV2Factory.Contract.IUniswapV2FactoryTransactor.contract.Transfer(opts) | |
| } | |
| // Transact invokes the (paid) contract method with params as input values. | |
| func (_IUniswapV2Factory *IUniswapV2FactoryRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { | |
| return _IUniswapV2Factory.Contract.IUniswapV2FactoryTransactor.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 (_IUniswapV2Factory *IUniswapV2FactoryCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { | |
| return _IUniswapV2Factory.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 (_IUniswapV2Factory *IUniswapV2FactoryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { | |
| return _IUniswapV2Factory.Contract.contract.Transfer(opts) | |
| } | |
| // Transact invokes the (paid) contract method with params as input values. | |
| func (_IUniswapV2Factory *IUniswapV2FactoryTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { | |
| return _IUniswapV2Factory.Contract.contract.Transact(opts, method, params...) | |
| } | |
| // AllPairs is a free data retrieval call binding the contract method 0x1e3dd18b. | |
| // | |
| // Solidity: function allPairs(uint256 ) view returns(address pair) | |
| func (_IUniswapV2Factory *IUniswapV2FactoryCaller) AllPairs(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error) { | |
| var out []interface{} | |
| err := _IUniswapV2Factory.contract.Call(opts, &out, "allPairs", arg0) | |
| if err != nil { | |
| return *new(common.Address), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) | |
| return out0, err | |
| } | |
| // AllPairs is a free data retrieval call binding the contract method 0x1e3dd18b. | |
| // | |
| // Solidity: function allPairs(uint256 ) view returns(address pair) | |
| func (_IUniswapV2Factory *IUniswapV2FactorySession) AllPairs(arg0 *big.Int) (common.Address, error) { | |
| return _IUniswapV2Factory.Contract.AllPairs(&_IUniswapV2Factory.CallOpts, arg0) | |
| } | |
| // AllPairs is a free data retrieval call binding the contract method 0x1e3dd18b. | |
| // | |
| // Solidity: function allPairs(uint256 ) view returns(address pair) | |
| func (_IUniswapV2Factory *IUniswapV2FactoryCallerSession) AllPairs(arg0 *big.Int) (common.Address, error) { | |
| return _IUniswapV2Factory.Contract.AllPairs(&_IUniswapV2Factory.CallOpts, arg0) | |
| } | |
| // AllPairsLength is a free data retrieval call binding the contract method 0x574f2ba3. | |
| // | |
| // Solidity: function allPairsLength() view returns(uint256) | |
| func (_IUniswapV2Factory *IUniswapV2FactoryCaller) AllPairsLength(opts *bind.CallOpts) (*big.Int, error) { | |
| var out []interface{} | |
| err := _IUniswapV2Factory.contract.Call(opts, &out, "allPairsLength") | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // AllPairsLength is a free data retrieval call binding the contract method 0x574f2ba3. | |
| // | |
| // Solidity: function allPairsLength() view returns(uint256) | |
| func (_IUniswapV2Factory *IUniswapV2FactorySession) AllPairsLength() (*big.Int, error) { | |
| return _IUniswapV2Factory.Contract.AllPairsLength(&_IUniswapV2Factory.CallOpts) | |
| } | |
| // AllPairsLength is a free data retrieval call binding the contract method 0x574f2ba3. | |
| // | |
| // Solidity: function allPairsLength() view returns(uint256) | |
| func (_IUniswapV2Factory *IUniswapV2FactoryCallerSession) AllPairsLength() (*big.Int, error) { | |
| return _IUniswapV2Factory.Contract.AllPairsLength(&_IUniswapV2Factory.CallOpts) | |
| } | |
| // FeeTo is a free data retrieval call binding the contract method 0x017e7e58. | |
| // | |
| // Solidity: function feeTo() view returns(address) | |
| func (_IUniswapV2Factory *IUniswapV2FactoryCaller) FeeTo(opts *bind.CallOpts) (common.Address, error) { | |
| var out []interface{} | |
| err := _IUniswapV2Factory.contract.Call(opts, &out, "feeTo") | |
| if err != nil { | |
| return *new(common.Address), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) | |
| return out0, err | |
| } | |
| // FeeTo is a free data retrieval call binding the contract method 0x017e7e58. | |
| // | |
| // Solidity: function feeTo() view returns(address) | |
| func (_IUniswapV2Factory *IUniswapV2FactorySession) FeeTo() (common.Address, error) { | |
| return _IUniswapV2Factory.Contract.FeeTo(&_IUniswapV2Factory.CallOpts) | |
| } | |
| // FeeTo is a free data retrieval call binding the contract method 0x017e7e58. | |
| // | |
| // Solidity: function feeTo() view returns(address) | |
| func (_IUniswapV2Factory *IUniswapV2FactoryCallerSession) FeeTo() (common.Address, error) { | |
| return _IUniswapV2Factory.Contract.FeeTo(&_IUniswapV2Factory.CallOpts) | |
| } | |
| // FeeToSetter is a free data retrieval call binding the contract method 0x094b7415. | |
| // | |
| // Solidity: function feeToSetter() view returns(address) | |
| func (_IUniswapV2Factory *IUniswapV2FactoryCaller) FeeToSetter(opts *bind.CallOpts) (common.Address, error) { | |
| var out []interface{} | |
| err := _IUniswapV2Factory.contract.Call(opts, &out, "feeToSetter") | |
| if err != nil { | |
| return *new(common.Address), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) | |
| return out0, err | |
| } | |
| // FeeToSetter is a free data retrieval call binding the contract method 0x094b7415. | |
| // | |
| // Solidity: function feeToSetter() view returns(address) | |
| func (_IUniswapV2Factory *IUniswapV2FactorySession) FeeToSetter() (common.Address, error) { | |
| return _IUniswapV2Factory.Contract.FeeToSetter(&_IUniswapV2Factory.CallOpts) | |
| } | |
| // FeeToSetter is a free data retrieval call binding the contract method 0x094b7415. | |
| // | |
| // Solidity: function feeToSetter() view returns(address) | |
| func (_IUniswapV2Factory *IUniswapV2FactoryCallerSession) FeeToSetter() (common.Address, error) { | |
| return _IUniswapV2Factory.Contract.FeeToSetter(&_IUniswapV2Factory.CallOpts) | |
| } | |
| // GetPair is a free data retrieval call binding the contract method 0xe6a43905. | |
| // | |
| // Solidity: function getPair(address tokenA, address tokenB) view returns(address pair) | |
| func (_IUniswapV2Factory *IUniswapV2FactoryCaller) GetPair(opts *bind.CallOpts, tokenA common.Address, tokenB common.Address) (common.Address, error) { | |
| var out []interface{} | |
| err := _IUniswapV2Factory.contract.Call(opts, &out, "getPair", tokenA, tokenB) | |
| if err != nil { | |
| return *new(common.Address), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) | |
| return out0, err | |
| } | |
| // GetPair is a free data retrieval call binding the contract method 0xe6a43905. | |
| // | |
| // Solidity: function getPair(address tokenA, address tokenB) view returns(address pair) | |
| func (_IUniswapV2Factory *IUniswapV2FactorySession) GetPair(tokenA common.Address, tokenB common.Address) (common.Address, error) { | |
| return _IUniswapV2Factory.Contract.GetPair(&_IUniswapV2Factory.CallOpts, tokenA, tokenB) | |
| } | |
| // GetPair is a free data retrieval call binding the contract method 0xe6a43905. | |
| // | |
| // Solidity: function getPair(address tokenA, address tokenB) view returns(address pair) | |
| func (_IUniswapV2Factory *IUniswapV2FactoryCallerSession) GetPair(tokenA common.Address, tokenB common.Address) (common.Address, error) { | |
| return _IUniswapV2Factory.Contract.GetPair(&_IUniswapV2Factory.CallOpts, tokenA, tokenB) | |
| } | |
| // CreatePair is a paid mutator transaction binding the contract method 0xc9c65396. | |
| // | |
| // Solidity: function createPair(address tokenA, address tokenB) returns(address pair) | |
| func (_IUniswapV2Factory *IUniswapV2FactoryTransactor) CreatePair(opts *bind.TransactOpts, tokenA common.Address, tokenB common.Address) (*types.Transaction, error) { | |
| return _IUniswapV2Factory.contract.Transact(opts, "createPair", tokenA, tokenB) | |
| } | |
| // CreatePair is a paid mutator transaction binding the contract method 0xc9c65396. | |
| // | |
| // Solidity: function createPair(address tokenA, address tokenB) returns(address pair) | |
| func (_IUniswapV2Factory *IUniswapV2FactorySession) CreatePair(tokenA common.Address, tokenB common.Address) (*types.Transaction, error) { | |
| return _IUniswapV2Factory.Contract.CreatePair(&_IUniswapV2Factory.TransactOpts, tokenA, tokenB) | |
| } | |
| // CreatePair is a paid mutator transaction binding the contract method 0xc9c65396. | |
| // | |
| // Solidity: function createPair(address tokenA, address tokenB) returns(address pair) | |
| func (_IUniswapV2Factory *IUniswapV2FactoryTransactorSession) CreatePair(tokenA common.Address, tokenB common.Address) (*types.Transaction, error) { | |
| return _IUniswapV2Factory.Contract.CreatePair(&_IUniswapV2Factory.TransactOpts, tokenA, tokenB) | |
| } | |
| // SetFeeTo is a paid mutator transaction binding the contract method 0xf46901ed. | |
| // | |
| // Solidity: function setFeeTo(address ) returns() | |
| func (_IUniswapV2Factory *IUniswapV2FactoryTransactor) SetFeeTo(opts *bind.TransactOpts, arg0 common.Address) (*types.Transaction, error) { | |
| return _IUniswapV2Factory.contract.Transact(opts, "setFeeTo", arg0) | |
| } | |
| // SetFeeTo is a paid mutator transaction binding the contract method 0xf46901ed. | |
| // | |
| // Solidity: function setFeeTo(address ) returns() | |
| func (_IUniswapV2Factory *IUniswapV2FactorySession) SetFeeTo(arg0 common.Address) (*types.Transaction, error) { | |
| return _IUniswapV2Factory.Contract.SetFeeTo(&_IUniswapV2Factory.TransactOpts, arg0) | |
| } | |
| // SetFeeTo is a paid mutator transaction binding the contract method 0xf46901ed. | |
| // | |
| // Solidity: function setFeeTo(address ) returns() | |
| func (_IUniswapV2Factory *IUniswapV2FactoryTransactorSession) SetFeeTo(arg0 common.Address) (*types.Transaction, error) { | |
| return _IUniswapV2Factory.Contract.SetFeeTo(&_IUniswapV2Factory.TransactOpts, arg0) | |
| } | |
| // SetFeeToSetter is a paid mutator transaction binding the contract method 0xa2e74af6. | |
| // | |
| // Solidity: function setFeeToSetter(address ) returns() | |
| func (_IUniswapV2Factory *IUniswapV2FactoryTransactor) SetFeeToSetter(opts *bind.TransactOpts, arg0 common.Address) (*types.Transaction, error) { | |
| return _IUniswapV2Factory.contract.Transact(opts, "setFeeToSetter", arg0) | |
| } | |
| // SetFeeToSetter is a paid mutator transaction binding the contract method 0xa2e74af6. | |
| // | |
| // Solidity: function setFeeToSetter(address ) returns() | |
| func (_IUniswapV2Factory *IUniswapV2FactorySession) SetFeeToSetter(arg0 common.Address) (*types.Transaction, error) { | |
| return _IUniswapV2Factory.Contract.SetFeeToSetter(&_IUniswapV2Factory.TransactOpts, arg0) | |
| } | |
| // SetFeeToSetter is a paid mutator transaction binding the contract method 0xa2e74af6. | |
| // | |
| // Solidity: function setFeeToSetter(address ) returns() | |
| func (_IUniswapV2Factory *IUniswapV2FactoryTransactorSession) SetFeeToSetter(arg0 common.Address) (*types.Transaction, error) { | |
| return _IUniswapV2Factory.Contract.SetFeeToSetter(&_IUniswapV2Factory.TransactOpts, arg0) | |
| } | |
| // IUniswapV2FactoryPairCreatedIterator is returned from FilterPairCreated and is used to iterate over the raw logs and unpacked data for PairCreated events raised by the IUniswapV2Factory contract. | |
| type IUniswapV2FactoryPairCreatedIterator struct { | |
| Event *IUniswapV2FactoryPairCreated // 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 *IUniswapV2FactoryPairCreatedIterator) 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(IUniswapV2FactoryPairCreated) | |
| 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(IUniswapV2FactoryPairCreated) | |
| 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 *IUniswapV2FactoryPairCreatedIterator) Error() error { | |
| return it.fail | |
| } | |
| // Close terminates the iteration process, releasing any pending underlying | |
| // resources. | |
| func (it *IUniswapV2FactoryPairCreatedIterator) Close() error { | |
| it.sub.Unsubscribe() | |
| return nil | |
| } | |
| // IUniswapV2FactoryPairCreated represents a PairCreated event raised by the IUniswapV2Factory contract. | |
| type IUniswapV2FactoryPairCreated struct { | |
| Token0 common.Address | |
| Token1 common.Address | |
| Pair common.Address | |
| Arg3 *big.Int | |
| Raw types.Log // Blockchain specific contextual infos | |
| } | |
| // FilterPairCreated is a free log retrieval operation binding the contract event 0x0d3648bd0f6ba80134a33ba9275ac585d9d315f0ad8355cddefde31afa28d0e9. | |
| // | |
| // Solidity: event PairCreated(address indexed token0, address indexed token1, address pair, uint256 arg3) | |
| func (_IUniswapV2Factory *IUniswapV2FactoryFilterer) FilterPairCreated(opts *bind.FilterOpts, token0 []common.Address, token1 []common.Address) (*IUniswapV2FactoryPairCreatedIterator, error) { | |
| var token0Rule []interface{} | |
| for _, token0Item := range token0 { | |
| token0Rule = append(token0Rule, token0Item) | |
| } | |
| var token1Rule []interface{} | |
| for _, token1Item := range token1 { | |
| token1Rule = append(token1Rule, token1Item) | |
| } | |
| logs, sub, err := _IUniswapV2Factory.contract.FilterLogs(opts, "PairCreated", token0Rule, token1Rule) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2FactoryPairCreatedIterator{contract: _IUniswapV2Factory.contract, event: "PairCreated", logs: logs, sub: sub}, nil | |
| } | |
| // WatchPairCreated is a free log subscription operation binding the contract event 0x0d3648bd0f6ba80134a33ba9275ac585d9d315f0ad8355cddefde31afa28d0e9. | |
| // | |
| // Solidity: event PairCreated(address indexed token0, address indexed token1, address pair, uint256 arg3) | |
| func (_IUniswapV2Factory *IUniswapV2FactoryFilterer) WatchPairCreated(opts *bind.WatchOpts, sink chan<- *IUniswapV2FactoryPairCreated, token0 []common.Address, token1 []common.Address) (event.Subscription, error) { | |
| var token0Rule []interface{} | |
| for _, token0Item := range token0 { | |
| token0Rule = append(token0Rule, token0Item) | |
| } | |
| var token1Rule []interface{} | |
| for _, token1Item := range token1 { | |
| token1Rule = append(token1Rule, token1Item) | |
| } | |
| logs, sub, err := _IUniswapV2Factory.contract.WatchLogs(opts, "PairCreated", token0Rule, token1Rule) | |
| 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(IUniswapV2FactoryPairCreated) | |
| if err := _IUniswapV2Factory.contract.UnpackLog(event, "PairCreated", 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 | |
| } | |
| // ParsePairCreated is a log parse operation binding the contract event 0x0d3648bd0f6ba80134a33ba9275ac585d9d315f0ad8355cddefde31afa28d0e9. | |
| // | |
| // Solidity: event PairCreated(address indexed token0, address indexed token1, address pair, uint256 arg3) | |
| func (_IUniswapV2Factory *IUniswapV2FactoryFilterer) ParsePairCreated(log types.Log) (*IUniswapV2FactoryPairCreated, error) { | |
| event := new(IUniswapV2FactoryPairCreated) | |
| if err := _IUniswapV2Factory.contract.UnpackLog(event, "PairCreated", log); err != nil { | |
| return nil, err | |
| } | |
| return event, nil | |
| } | |
| // IUniswapV2PairABI is the input ABI used to generate the binding from. | |
| const IUniswapV2PairABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"Burn\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"}],\"name\":\"Mint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount0In\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount1In\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount0Out\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount1Out\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"Swap\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint112\",\"name\":\"reserve0\",\"type\":\"uint112\"},{\"indexed\":false,\"internalType\":\"uint112\",\"name\":\"reserve1\",\"type\":\"uint112\"}],\"name\":\"Sync\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[],\"name\":\"DOMAIN_SEPARATOR\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"MINIMUM_LIQUIDITY\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"PERMIT_TYPEHASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"burn\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"factory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"getReserves\",\"outputs\":[{\"internalType\":\"uint112\",\"name\":\"reserve0\",\"type\":\"uint112\"},{\"internalType\":\"uint112\",\"name\":\"reserve1\",\"type\":\"uint112\"},{\"internalType\":\"uint32\",\"name\":\"blockTimestampLast\",\"type\":\"uint32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"kLast\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"mint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"liquidity\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"nonces\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"permit\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"price0CumulativeLast\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"price1CumulativeLast\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"skim\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount0Out\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount1Out\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"swap\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"sync\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"token0\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"token1\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" | |
| // IUniswapV2PairFuncSigs maps the 4-byte function signature to its string representation. | |
| var IUniswapV2PairFuncSigs = map[string]string{ | |
| "3644e515": "DOMAIN_SEPARATOR()", | |
| "ba9a7a56": "MINIMUM_LIQUIDITY()", | |
| "30adf81f": "PERMIT_TYPEHASH()", | |
| "dd62ed3e": "allowance(address,address)", | |
| "095ea7b3": "approve(address,uint256)", | |
| "70a08231": "balanceOf(address)", | |
| "89afcb44": "burn(address)", | |
| "313ce567": "decimals()", | |
| "c45a0155": "factory()", | |
| "0902f1ac": "getReserves()", | |
| "485cc955": "initialize(address,address)", | |
| "7464fc3d": "kLast()", | |
| "6a627842": "mint(address)", | |
| "06fdde03": "name()", | |
| "7ecebe00": "nonces(address)", | |
| "d505accf": "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)", | |
| "5909c0d5": "price0CumulativeLast()", | |
| "5a3d5493": "price1CumulativeLast()", | |
| "bc25cf77": "skim(address)", | |
| "022c0d9f": "swap(uint256,uint256,address,bytes)", | |
| "95d89b41": "symbol()", | |
| "fff6cae9": "sync()", | |
| "0dfe1681": "token0()", | |
| "d21220a7": "token1()", | |
| "18160ddd": "totalSupply()", | |
| "a9059cbb": "transfer(address,uint256)", | |
| "23b872dd": "transferFrom(address,address,uint256)", | |
| } | |
| // IUniswapV2Pair is an auto generated Go binding around an Ethereum contract. | |
| type IUniswapV2Pair struct { | |
| IUniswapV2PairCaller // Read-only binding to the contract | |
| IUniswapV2PairTransactor // Write-only binding to the contract | |
| IUniswapV2PairFilterer // Log filterer for contract events | |
| } | |
| // IUniswapV2PairCaller is an auto generated read-only Go binding around an Ethereum contract. | |
| type IUniswapV2PairCaller struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // IUniswapV2PairTransactor is an auto generated write-only Go binding around an Ethereum contract. | |
| type IUniswapV2PairTransactor struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // IUniswapV2PairFilterer is an auto generated log filtering Go binding around an Ethereum contract events. | |
| type IUniswapV2PairFilterer struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // IUniswapV2PairSession is an auto generated Go binding around an Ethereum contract, | |
| // with pre-set call and transact options. | |
| type IUniswapV2PairSession struct { | |
| Contract *IUniswapV2Pair // 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 | |
| } | |
| // IUniswapV2PairCallerSession is an auto generated read-only Go binding around an Ethereum contract, | |
| // with pre-set call options. | |
| type IUniswapV2PairCallerSession struct { | |
| Contract *IUniswapV2PairCaller // Generic contract caller binding to set the session for | |
| CallOpts bind.CallOpts // Call options to use throughout this session | |
| } | |
| // IUniswapV2PairTransactorSession is an auto generated write-only Go binding around an Ethereum contract, | |
| // with pre-set transact options. | |
| type IUniswapV2PairTransactorSession struct { | |
| Contract *IUniswapV2PairTransactor // Generic contract transactor binding to set the session for | |
| TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session | |
| } | |
| // IUniswapV2PairRaw is an auto generated low-level Go binding around an Ethereum contract. | |
| type IUniswapV2PairRaw struct { | |
| Contract *IUniswapV2Pair // Generic contract binding to access the raw methods on | |
| } | |
| // IUniswapV2PairCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. | |
| type IUniswapV2PairCallerRaw struct { | |
| Contract *IUniswapV2PairCaller // Generic read-only contract binding to access the raw methods on | |
| } | |
| // IUniswapV2PairTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. | |
| type IUniswapV2PairTransactorRaw struct { | |
| Contract *IUniswapV2PairTransactor // Generic write-only contract binding to access the raw methods on | |
| } | |
| // NewIUniswapV2Pair creates a new instance of IUniswapV2Pair, bound to a specific deployed contract. | |
| func NewIUniswapV2Pair(address common.Address, backend bind.ContractBackend) (*IUniswapV2Pair, error) { | |
| contract, err := bindIUniswapV2Pair(address, backend, backend, backend) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2Pair{IUniswapV2PairCaller: IUniswapV2PairCaller{contract: contract}, IUniswapV2PairTransactor: IUniswapV2PairTransactor{contract: contract}, IUniswapV2PairFilterer: IUniswapV2PairFilterer{contract: contract}}, nil | |
| } | |
| // NewIUniswapV2PairCaller creates a new read-only instance of IUniswapV2Pair, bound to a specific deployed contract. | |
| func NewIUniswapV2PairCaller(address common.Address, caller bind.ContractCaller) (*IUniswapV2PairCaller, error) { | |
| contract, err := bindIUniswapV2Pair(address, caller, nil, nil) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2PairCaller{contract: contract}, nil | |
| } | |
| // NewIUniswapV2PairTransactor creates a new write-only instance of IUniswapV2Pair, bound to a specific deployed contract. | |
| func NewIUniswapV2PairTransactor(address common.Address, transactor bind.ContractTransactor) (*IUniswapV2PairTransactor, error) { | |
| contract, err := bindIUniswapV2Pair(address, nil, transactor, nil) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2PairTransactor{contract: contract}, nil | |
| } | |
| // NewIUniswapV2PairFilterer creates a new log filterer instance of IUniswapV2Pair, bound to a specific deployed contract. | |
| func NewIUniswapV2PairFilterer(address common.Address, filterer bind.ContractFilterer) (*IUniswapV2PairFilterer, error) { | |
| contract, err := bindIUniswapV2Pair(address, nil, nil, filterer) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2PairFilterer{contract: contract}, nil | |
| } | |
| // bindIUniswapV2Pair binds a generic wrapper to an already deployed contract. | |
| func bindIUniswapV2Pair(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { | |
| parsed, err := abi.JSON(strings.NewReader(IUniswapV2PairABI)) | |
| 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 (_IUniswapV2Pair *IUniswapV2PairRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { | |
| return _IUniswapV2Pair.Contract.IUniswapV2PairCaller.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 (_IUniswapV2Pair *IUniswapV2PairRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.IUniswapV2PairTransactor.contract.Transfer(opts) | |
| } | |
| // Transact invokes the (paid) contract method with params as input values. | |
| func (_IUniswapV2Pair *IUniswapV2PairRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.IUniswapV2PairTransactor.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 (_IUniswapV2Pair *IUniswapV2PairCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { | |
| return _IUniswapV2Pair.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 (_IUniswapV2Pair *IUniswapV2PairTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.contract.Transfer(opts) | |
| } | |
| // Transact invokes the (paid) contract method with params as input values. | |
| func (_IUniswapV2Pair *IUniswapV2PairTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.contract.Transact(opts, method, params...) | |
| } | |
| // DOMAINSEPARATOR is a free data retrieval call binding the contract method 0x3644e515. | |
| // | |
| // Solidity: function DOMAIN_SEPARATOR() view returns(bytes32) | |
| func (_IUniswapV2Pair *IUniswapV2PairCaller) DOMAINSEPARATOR(opts *bind.CallOpts) ([32]byte, error) { | |
| var out []interface{} | |
| err := _IUniswapV2Pair.contract.Call(opts, &out, "DOMAIN_SEPARATOR") | |
| if err != nil { | |
| return *new([32]byte), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) | |
| return out0, err | |
| } | |
| // DOMAINSEPARATOR is a free data retrieval call binding the contract method 0x3644e515. | |
| // | |
| // Solidity: function DOMAIN_SEPARATOR() view returns(bytes32) | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) DOMAINSEPARATOR() ([32]byte, error) { | |
| return _IUniswapV2Pair.Contract.DOMAINSEPARATOR(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // DOMAINSEPARATOR is a free data retrieval call binding the contract method 0x3644e515. | |
| // | |
| // Solidity: function DOMAIN_SEPARATOR() view returns(bytes32) | |
| func (_IUniswapV2Pair *IUniswapV2PairCallerSession) DOMAINSEPARATOR() ([32]byte, error) { | |
| return _IUniswapV2Pair.Contract.DOMAINSEPARATOR(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // MINIMUMLIQUIDITY is a free data retrieval call binding the contract method 0xba9a7a56. | |
| // | |
| // Solidity: function MINIMUM_LIQUIDITY() pure returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairCaller) MINIMUMLIQUIDITY(opts *bind.CallOpts) (*big.Int, error) { | |
| var out []interface{} | |
| err := _IUniswapV2Pair.contract.Call(opts, &out, "MINIMUM_LIQUIDITY") | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // MINIMUMLIQUIDITY is a free data retrieval call binding the contract method 0xba9a7a56. | |
| // | |
| // Solidity: function MINIMUM_LIQUIDITY() pure returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) MINIMUMLIQUIDITY() (*big.Int, error) { | |
| return _IUniswapV2Pair.Contract.MINIMUMLIQUIDITY(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // MINIMUMLIQUIDITY is a free data retrieval call binding the contract method 0xba9a7a56. | |
| // | |
| // Solidity: function MINIMUM_LIQUIDITY() pure returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairCallerSession) MINIMUMLIQUIDITY() (*big.Int, error) { | |
| return _IUniswapV2Pair.Contract.MINIMUMLIQUIDITY(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // PERMITTYPEHASH is a free data retrieval call binding the contract method 0x30adf81f. | |
| // | |
| // Solidity: function PERMIT_TYPEHASH() pure returns(bytes32) | |
| func (_IUniswapV2Pair *IUniswapV2PairCaller) PERMITTYPEHASH(opts *bind.CallOpts) ([32]byte, error) { | |
| var out []interface{} | |
| err := _IUniswapV2Pair.contract.Call(opts, &out, "PERMIT_TYPEHASH") | |
| if err != nil { | |
| return *new([32]byte), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) | |
| return out0, err | |
| } | |
| // PERMITTYPEHASH is a free data retrieval call binding the contract method 0x30adf81f. | |
| // | |
| // Solidity: function PERMIT_TYPEHASH() pure returns(bytes32) | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) PERMITTYPEHASH() ([32]byte, error) { | |
| return _IUniswapV2Pair.Contract.PERMITTYPEHASH(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // PERMITTYPEHASH is a free data retrieval call binding the contract method 0x30adf81f. | |
| // | |
| // Solidity: function PERMIT_TYPEHASH() pure returns(bytes32) | |
| func (_IUniswapV2Pair *IUniswapV2PairCallerSession) PERMITTYPEHASH() ([32]byte, error) { | |
| return _IUniswapV2Pair.Contract.PERMITTYPEHASH(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. | |
| // | |
| // Solidity: function allowance(address owner, address spender) view returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { | |
| var out []interface{} | |
| err := _IUniswapV2Pair.contract.Call(opts, &out, "allowance", owner, spender) | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. | |
| // | |
| // Solidity: function allowance(address owner, address spender) view returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { | |
| return _IUniswapV2Pair.Contract.Allowance(&_IUniswapV2Pair.CallOpts, owner, spender) | |
| } | |
| // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. | |
| // | |
| // Solidity: function allowance(address owner, address spender) view returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { | |
| return _IUniswapV2Pair.Contract.Allowance(&_IUniswapV2Pair.CallOpts, owner, spender) | |
| } | |
| // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. | |
| // | |
| // Solidity: function balanceOf(address owner) view returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error) { | |
| var out []interface{} | |
| err := _IUniswapV2Pair.contract.Call(opts, &out, "balanceOf", owner) | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. | |
| // | |
| // Solidity: function balanceOf(address owner) view returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) BalanceOf(owner common.Address) (*big.Int, error) { | |
| return _IUniswapV2Pair.Contract.BalanceOf(&_IUniswapV2Pair.CallOpts, owner) | |
| } | |
| // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. | |
| // | |
| // Solidity: function balanceOf(address owner) view returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairCallerSession) BalanceOf(owner common.Address) (*big.Int, error) { | |
| return _IUniswapV2Pair.Contract.BalanceOf(&_IUniswapV2Pair.CallOpts, owner) | |
| } | |
| // Decimals is a free data retrieval call binding the contract method 0x313ce567. | |
| // | |
| // Solidity: function decimals() pure returns(uint8) | |
| func (_IUniswapV2Pair *IUniswapV2PairCaller) Decimals(opts *bind.CallOpts) (uint8, error) { | |
| var out []interface{} | |
| err := _IUniswapV2Pair.contract.Call(opts, &out, "decimals") | |
| if err != nil { | |
| return *new(uint8), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) | |
| return out0, err | |
| } | |
| // Decimals is a free data retrieval call binding the contract method 0x313ce567. | |
| // | |
| // Solidity: function decimals() pure returns(uint8) | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) Decimals() (uint8, error) { | |
| return _IUniswapV2Pair.Contract.Decimals(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // Decimals is a free data retrieval call binding the contract method 0x313ce567. | |
| // | |
| // Solidity: function decimals() pure returns(uint8) | |
| func (_IUniswapV2Pair *IUniswapV2PairCallerSession) Decimals() (uint8, error) { | |
| return _IUniswapV2Pair.Contract.Decimals(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // Factory is a free data retrieval call binding the contract method 0xc45a0155. | |
| // | |
| // Solidity: function factory() view returns(address) | |
| func (_IUniswapV2Pair *IUniswapV2PairCaller) Factory(opts *bind.CallOpts) (common.Address, error) { | |
| var out []interface{} | |
| err := _IUniswapV2Pair.contract.Call(opts, &out, "factory") | |
| if err != nil { | |
| return *new(common.Address), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) | |
| return out0, err | |
| } | |
| // Factory is a free data retrieval call binding the contract method 0xc45a0155. | |
| // | |
| // Solidity: function factory() view returns(address) | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) Factory() (common.Address, error) { | |
| return _IUniswapV2Pair.Contract.Factory(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // Factory is a free data retrieval call binding the contract method 0xc45a0155. | |
| // | |
| // Solidity: function factory() view returns(address) | |
| func (_IUniswapV2Pair *IUniswapV2PairCallerSession) Factory() (common.Address, error) { | |
| return _IUniswapV2Pair.Contract.Factory(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // GetReserves is a free data retrieval call binding the contract method 0x0902f1ac. | |
| // | |
| // Solidity: function getReserves() view returns(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) | |
| func (_IUniswapV2Pair *IUniswapV2PairCaller) GetReserves(opts *bind.CallOpts) (struct { | |
| Reserve0 *big.Int | |
| Reserve1 *big.Int | |
| BlockTimestampLast uint32 | |
| }, error) { | |
| var out []interface{} | |
| err := _IUniswapV2Pair.contract.Call(opts, &out, "getReserves") | |
| outstruct := new(struct { | |
| Reserve0 *big.Int | |
| Reserve1 *big.Int | |
| BlockTimestampLast uint32 | |
| }) | |
| // ! Fix generated code | |
| if err != nil { | |
| return *outstruct, err | |
| } | |
| outstruct.Reserve0 = out[0].(*big.Int) | |
| outstruct.Reserve1 = out[1].(*big.Int) | |
| outstruct.BlockTimestampLast = out[2].(uint32) | |
| return *outstruct, err | |
| } | |
| // GetReserves is a free data retrieval call binding the contract method 0x0902f1ac. | |
| // | |
| // Solidity: function getReserves() view returns(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) GetReserves() (struct { | |
| Reserve0 *big.Int | |
| Reserve1 *big.Int | |
| BlockTimestampLast uint32 | |
| }, error) { | |
| return _IUniswapV2Pair.Contract.GetReserves(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // GetReserves is a free data retrieval call binding the contract method 0x0902f1ac. | |
| // | |
| // Solidity: function getReserves() view returns(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) | |
| func (_IUniswapV2Pair *IUniswapV2PairCallerSession) GetReserves() (struct { | |
| Reserve0 *big.Int | |
| Reserve1 *big.Int | |
| BlockTimestampLast uint32 | |
| }, error) { | |
| return _IUniswapV2Pair.Contract.GetReserves(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // KLast is a free data retrieval call binding the contract method 0x7464fc3d. | |
| // | |
| // Solidity: function kLast() view returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairCaller) KLast(opts *bind.CallOpts) (*big.Int, error) { | |
| var out []interface{} | |
| err := _IUniswapV2Pair.contract.Call(opts, &out, "kLast") | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // KLast is a free data retrieval call binding the contract method 0x7464fc3d. | |
| // | |
| // Solidity: function kLast() view returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) KLast() (*big.Int, error) { | |
| return _IUniswapV2Pair.Contract.KLast(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // KLast is a free data retrieval call binding the contract method 0x7464fc3d. | |
| // | |
| // Solidity: function kLast() view returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairCallerSession) KLast() (*big.Int, error) { | |
| return _IUniswapV2Pair.Contract.KLast(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // Name is a free data retrieval call binding the contract method 0x06fdde03. | |
| // | |
| // Solidity: function name() pure returns(string) | |
| func (_IUniswapV2Pair *IUniswapV2PairCaller) Name(opts *bind.CallOpts) (string, error) { | |
| var out []interface{} | |
| err := _IUniswapV2Pair.contract.Call(opts, &out, "name") | |
| if err != nil { | |
| return *new(string), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(string)).(*string) | |
| return out0, err | |
| } | |
| // Name is a free data retrieval call binding the contract method 0x06fdde03. | |
| // | |
| // Solidity: function name() pure returns(string) | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) Name() (string, error) { | |
| return _IUniswapV2Pair.Contract.Name(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // Name is a free data retrieval call binding the contract method 0x06fdde03. | |
| // | |
| // Solidity: function name() pure returns(string) | |
| func (_IUniswapV2Pair *IUniswapV2PairCallerSession) Name() (string, error) { | |
| return _IUniswapV2Pair.Contract.Name(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // Nonces is a free data retrieval call binding the contract method 0x7ecebe00. | |
| // | |
| // Solidity: function nonces(address owner) view returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairCaller) Nonces(opts *bind.CallOpts, owner common.Address) (*big.Int, error) { | |
| var out []interface{} | |
| err := _IUniswapV2Pair.contract.Call(opts, &out, "nonces", owner) | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // Nonces is a free data retrieval call binding the contract method 0x7ecebe00. | |
| // | |
| // Solidity: function nonces(address owner) view returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) Nonces(owner common.Address) (*big.Int, error) { | |
| return _IUniswapV2Pair.Contract.Nonces(&_IUniswapV2Pair.CallOpts, owner) | |
| } | |
| // Nonces is a free data retrieval call binding the contract method 0x7ecebe00. | |
| // | |
| // Solidity: function nonces(address owner) view returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairCallerSession) Nonces(owner common.Address) (*big.Int, error) { | |
| return _IUniswapV2Pair.Contract.Nonces(&_IUniswapV2Pair.CallOpts, owner) | |
| } | |
| // Price0CumulativeLast is a free data retrieval call binding the contract method 0x5909c0d5. | |
| // | |
| // Solidity: function price0CumulativeLast() view returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairCaller) Price0CumulativeLast(opts *bind.CallOpts) (*big.Int, error) { | |
| var out []interface{} | |
| err := _IUniswapV2Pair.contract.Call(opts, &out, "price0CumulativeLast") | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // Price0CumulativeLast is a free data retrieval call binding the contract method 0x5909c0d5. | |
| // | |
| // Solidity: function price0CumulativeLast() view returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) Price0CumulativeLast() (*big.Int, error) { | |
| return _IUniswapV2Pair.Contract.Price0CumulativeLast(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // Price0CumulativeLast is a free data retrieval call binding the contract method 0x5909c0d5. | |
| // | |
| // Solidity: function price0CumulativeLast() view returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairCallerSession) Price0CumulativeLast() (*big.Int, error) { | |
| return _IUniswapV2Pair.Contract.Price0CumulativeLast(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // Price1CumulativeLast is a free data retrieval call binding the contract method 0x5a3d5493. | |
| // | |
| // Solidity: function price1CumulativeLast() view returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairCaller) Price1CumulativeLast(opts *bind.CallOpts) (*big.Int, error) { | |
| var out []interface{} | |
| err := _IUniswapV2Pair.contract.Call(opts, &out, "price1CumulativeLast") | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // Price1CumulativeLast is a free data retrieval call binding the contract method 0x5a3d5493. | |
| // | |
| // Solidity: function price1CumulativeLast() view returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) Price1CumulativeLast() (*big.Int, error) { | |
| return _IUniswapV2Pair.Contract.Price1CumulativeLast(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // Price1CumulativeLast is a free data retrieval call binding the contract method 0x5a3d5493. | |
| // | |
| // Solidity: function price1CumulativeLast() view returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairCallerSession) Price1CumulativeLast() (*big.Int, error) { | |
| return _IUniswapV2Pair.Contract.Price1CumulativeLast(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // Symbol is a free data retrieval call binding the contract method 0x95d89b41. | |
| // | |
| // Solidity: function symbol() pure returns(string) | |
| func (_IUniswapV2Pair *IUniswapV2PairCaller) Symbol(opts *bind.CallOpts) (string, error) { | |
| var out []interface{} | |
| err := _IUniswapV2Pair.contract.Call(opts, &out, "symbol") | |
| if err != nil { | |
| return *new(string), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(string)).(*string) | |
| return out0, err | |
| } | |
| // Symbol is a free data retrieval call binding the contract method 0x95d89b41. | |
| // | |
| // Solidity: function symbol() pure returns(string) | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) Symbol() (string, error) { | |
| return _IUniswapV2Pair.Contract.Symbol(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // Symbol is a free data retrieval call binding the contract method 0x95d89b41. | |
| // | |
| // Solidity: function symbol() pure returns(string) | |
| func (_IUniswapV2Pair *IUniswapV2PairCallerSession) Symbol() (string, error) { | |
| return _IUniswapV2Pair.Contract.Symbol(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // Token0 is a free data retrieval call binding the contract method 0x0dfe1681. | |
| // | |
| // Solidity: function token0() view returns(address) | |
| func (_IUniswapV2Pair *IUniswapV2PairCaller) Token0(opts *bind.CallOpts) (common.Address, error) { | |
| var out []interface{} | |
| err := _IUniswapV2Pair.contract.Call(opts, &out, "token0") | |
| if err != nil { | |
| return *new(common.Address), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) | |
| return out0, err | |
| } | |
| // Token0 is a free data retrieval call binding the contract method 0x0dfe1681. | |
| // | |
| // Solidity: function token0() view returns(address) | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) Token0() (common.Address, error) { | |
| return _IUniswapV2Pair.Contract.Token0(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // Token0 is a free data retrieval call binding the contract method 0x0dfe1681. | |
| // | |
| // Solidity: function token0() view returns(address) | |
| func (_IUniswapV2Pair *IUniswapV2PairCallerSession) Token0() (common.Address, error) { | |
| return _IUniswapV2Pair.Contract.Token0(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // Token1 is a free data retrieval call binding the contract method 0xd21220a7. | |
| // | |
| // Solidity: function token1() view returns(address) | |
| func (_IUniswapV2Pair *IUniswapV2PairCaller) Token1(opts *bind.CallOpts) (common.Address, error) { | |
| var out []interface{} | |
| err := _IUniswapV2Pair.contract.Call(opts, &out, "token1") | |
| if err != nil { | |
| return *new(common.Address), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) | |
| return out0, err | |
| } | |
| // Token1 is a free data retrieval call binding the contract method 0xd21220a7. | |
| // | |
| // Solidity: function token1() view returns(address) | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) Token1() (common.Address, error) { | |
| return _IUniswapV2Pair.Contract.Token1(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // Token1 is a free data retrieval call binding the contract method 0xd21220a7. | |
| // | |
| // Solidity: function token1() view returns(address) | |
| func (_IUniswapV2Pair *IUniswapV2PairCallerSession) Token1() (common.Address, error) { | |
| return _IUniswapV2Pair.Contract.Token1(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. | |
| // | |
| // Solidity: function totalSupply() view returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { | |
| var out []interface{} | |
| err := _IUniswapV2Pair.contract.Call(opts, &out, "totalSupply") | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. | |
| // | |
| // Solidity: function totalSupply() view returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) TotalSupply() (*big.Int, error) { | |
| return _IUniswapV2Pair.Contract.TotalSupply(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. | |
| // | |
| // Solidity: function totalSupply() view returns(uint256) | |
| func (_IUniswapV2Pair *IUniswapV2PairCallerSession) TotalSupply() (*big.Int, error) { | |
| return _IUniswapV2Pair.Contract.TotalSupply(&_IUniswapV2Pair.CallOpts) | |
| } | |
| // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. | |
| // | |
| // Solidity: function approve(address spender, uint256 value) returns(bool) | |
| func (_IUniswapV2Pair *IUniswapV2PairTransactor) Approve(opts *bind.TransactOpts, spender common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.contract.Transact(opts, "approve", spender, value) | |
| } | |
| // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. | |
| // | |
| // Solidity: function approve(address spender, uint256 value) returns(bool) | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) Approve(spender common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.Approve(&_IUniswapV2Pair.TransactOpts, spender, value) | |
| } | |
| // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. | |
| // | |
| // Solidity: function approve(address spender, uint256 value) returns(bool) | |
| func (_IUniswapV2Pair *IUniswapV2PairTransactorSession) Approve(spender common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.Approve(&_IUniswapV2Pair.TransactOpts, spender, value) | |
| } | |
| // Burn is a paid mutator transaction binding the contract method 0x89afcb44. | |
| // | |
| // Solidity: function burn(address to) returns(uint256 amount0, uint256 amount1) | |
| func (_IUniswapV2Pair *IUniswapV2PairTransactor) Burn(opts *bind.TransactOpts, to common.Address) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.contract.Transact(opts, "burn", to) | |
| } | |
| // Burn is a paid mutator transaction binding the contract method 0x89afcb44. | |
| // | |
| // Solidity: function burn(address to) returns(uint256 amount0, uint256 amount1) | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) Burn(to common.Address) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.Burn(&_IUniswapV2Pair.TransactOpts, to) | |
| } | |
| // Burn is a paid mutator transaction binding the contract method 0x89afcb44. | |
| // | |
| // Solidity: function burn(address to) returns(uint256 amount0, uint256 amount1) | |
| func (_IUniswapV2Pair *IUniswapV2PairTransactorSession) Burn(to common.Address) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.Burn(&_IUniswapV2Pair.TransactOpts, to) | |
| } | |
| // Initialize is a paid mutator transaction binding the contract method 0x485cc955. | |
| // | |
| // Solidity: function initialize(address , address ) returns() | |
| func (_IUniswapV2Pair *IUniswapV2PairTransactor) Initialize(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.contract.Transact(opts, "initialize", arg0, arg1) | |
| } | |
| // Initialize is a paid mutator transaction binding the contract method 0x485cc955. | |
| // | |
| // Solidity: function initialize(address , address ) returns() | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) Initialize(arg0 common.Address, arg1 common.Address) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.Initialize(&_IUniswapV2Pair.TransactOpts, arg0, arg1) | |
| } | |
| // Initialize is a paid mutator transaction binding the contract method 0x485cc955. | |
| // | |
| // Solidity: function initialize(address , address ) returns() | |
| func (_IUniswapV2Pair *IUniswapV2PairTransactorSession) Initialize(arg0 common.Address, arg1 common.Address) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.Initialize(&_IUniswapV2Pair.TransactOpts, arg0, arg1) | |
| } | |
| // Mint is a paid mutator transaction binding the contract method 0x6a627842. | |
| // | |
| // Solidity: function mint(address to) returns(uint256 liquidity) | |
| func (_IUniswapV2Pair *IUniswapV2PairTransactor) Mint(opts *bind.TransactOpts, to common.Address) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.contract.Transact(opts, "mint", to) | |
| } | |
| // Mint is a paid mutator transaction binding the contract method 0x6a627842. | |
| // | |
| // Solidity: function mint(address to) returns(uint256 liquidity) | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) Mint(to common.Address) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.Mint(&_IUniswapV2Pair.TransactOpts, to) | |
| } | |
| // Mint is a paid mutator transaction binding the contract method 0x6a627842. | |
| // | |
| // Solidity: function mint(address to) returns(uint256 liquidity) | |
| func (_IUniswapV2Pair *IUniswapV2PairTransactorSession) Mint(to common.Address) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.Mint(&_IUniswapV2Pair.TransactOpts, to) | |
| } | |
| // Permit is a paid mutator transaction binding the contract method 0xd505accf. | |
| // | |
| // Solidity: function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) returns() | |
| func (_IUniswapV2Pair *IUniswapV2PairTransactor) Permit(opts *bind.TransactOpts, owner common.Address, spender common.Address, value *big.Int, deadline *big.Int, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.contract.Transact(opts, "permit", owner, spender, value, deadline, v, r, s) | |
| } | |
| // Permit is a paid mutator transaction binding the contract method 0xd505accf. | |
| // | |
| // Solidity: function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) returns() | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) Permit(owner common.Address, spender common.Address, value *big.Int, deadline *big.Int, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.Permit(&_IUniswapV2Pair.TransactOpts, owner, spender, value, deadline, v, r, s) | |
| } | |
| // Permit is a paid mutator transaction binding the contract method 0xd505accf. | |
| // | |
| // Solidity: function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) returns() | |
| func (_IUniswapV2Pair *IUniswapV2PairTransactorSession) Permit(owner common.Address, spender common.Address, value *big.Int, deadline *big.Int, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.Permit(&_IUniswapV2Pair.TransactOpts, owner, spender, value, deadline, v, r, s) | |
| } | |
| // Skim is a paid mutator transaction binding the contract method 0xbc25cf77. | |
| // | |
| // Solidity: function skim(address to) returns() | |
| func (_IUniswapV2Pair *IUniswapV2PairTransactor) Skim(opts *bind.TransactOpts, to common.Address) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.contract.Transact(opts, "skim", to) | |
| } | |
| // Skim is a paid mutator transaction binding the contract method 0xbc25cf77. | |
| // | |
| // Solidity: function skim(address to) returns() | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) Skim(to common.Address) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.Skim(&_IUniswapV2Pair.TransactOpts, to) | |
| } | |
| // Skim is a paid mutator transaction binding the contract method 0xbc25cf77. | |
| // | |
| // Solidity: function skim(address to) returns() | |
| func (_IUniswapV2Pair *IUniswapV2PairTransactorSession) Skim(to common.Address) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.Skim(&_IUniswapV2Pair.TransactOpts, to) | |
| } | |
| // Swap is a paid mutator transaction binding the contract method 0x022c0d9f. | |
| // | |
| // Solidity: function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes data) returns() | |
| func (_IUniswapV2Pair *IUniswapV2PairTransactor) Swap(opts *bind.TransactOpts, amount0Out *big.Int, amount1Out *big.Int, to common.Address, data []byte) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.contract.Transact(opts, "swap", amount0Out, amount1Out, to, data) | |
| } | |
| // Swap is a paid mutator transaction binding the contract method 0x022c0d9f. | |
| // | |
| // Solidity: function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes data) returns() | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) Swap(amount0Out *big.Int, amount1Out *big.Int, to common.Address, data []byte) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.Swap(&_IUniswapV2Pair.TransactOpts, amount0Out, amount1Out, to, data) | |
| } | |
| // Swap is a paid mutator transaction binding the contract method 0x022c0d9f. | |
| // | |
| // Solidity: function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes data) returns() | |
| func (_IUniswapV2Pair *IUniswapV2PairTransactorSession) Swap(amount0Out *big.Int, amount1Out *big.Int, to common.Address, data []byte) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.Swap(&_IUniswapV2Pair.TransactOpts, amount0Out, amount1Out, to, data) | |
| } | |
| // Sync is a paid mutator transaction binding the contract method 0xfff6cae9. | |
| // | |
| // Solidity: function sync() returns() | |
| func (_IUniswapV2Pair *IUniswapV2PairTransactor) Sync(opts *bind.TransactOpts) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.contract.Transact(opts, "sync") | |
| } | |
| // Sync is a paid mutator transaction binding the contract method 0xfff6cae9. | |
| // | |
| // Solidity: function sync() returns() | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) Sync() (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.Sync(&_IUniswapV2Pair.TransactOpts) | |
| } | |
| // Sync is a paid mutator transaction binding the contract method 0xfff6cae9. | |
| // | |
| // Solidity: function sync() returns() | |
| func (_IUniswapV2Pair *IUniswapV2PairTransactorSession) Sync() (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.Sync(&_IUniswapV2Pair.TransactOpts) | |
| } | |
| // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. | |
| // | |
| // Solidity: function transfer(address to, uint256 value) returns(bool) | |
| func (_IUniswapV2Pair *IUniswapV2PairTransactor) Transfer(opts *bind.TransactOpts, to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.contract.Transact(opts, "transfer", to, value) | |
| } | |
| // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. | |
| // | |
| // Solidity: function transfer(address to, uint256 value) returns(bool) | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.Transfer(&_IUniswapV2Pair.TransactOpts, to, value) | |
| } | |
| // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. | |
| // | |
| // Solidity: function transfer(address to, uint256 value) returns(bool) | |
| func (_IUniswapV2Pair *IUniswapV2PairTransactorSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.Transfer(&_IUniswapV2Pair.TransactOpts, to, value) | |
| } | |
| // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. | |
| // | |
| // Solidity: function transferFrom(address from, address to, uint256 value) returns(bool) | |
| func (_IUniswapV2Pair *IUniswapV2PairTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.contract.Transact(opts, "transferFrom", from, to, value) | |
| } | |
| // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. | |
| // | |
| // Solidity: function transferFrom(address from, address to, uint256 value) returns(bool) | |
| func (_IUniswapV2Pair *IUniswapV2PairSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.TransferFrom(&_IUniswapV2Pair.TransactOpts, from, to, value) | |
| } | |
| // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. | |
| // | |
| // Solidity: function transferFrom(address from, address to, uint256 value) returns(bool) | |
| func (_IUniswapV2Pair *IUniswapV2PairTransactorSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _IUniswapV2Pair.Contract.TransferFrom(&_IUniswapV2Pair.TransactOpts, from, to, value) | |
| } | |
| // IUniswapV2PairApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the IUniswapV2Pair contract. | |
| type IUniswapV2PairApprovalIterator struct { | |
| Event *IUniswapV2PairApproval // 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 *IUniswapV2PairApprovalIterator) 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(IUniswapV2PairApproval) | |
| 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(IUniswapV2PairApproval) | |
| 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 *IUniswapV2PairApprovalIterator) Error() error { | |
| return it.fail | |
| } | |
| // Close terminates the iteration process, releasing any pending underlying | |
| // resources. | |
| func (it *IUniswapV2PairApprovalIterator) Close() error { | |
| it.sub.Unsubscribe() | |
| return nil | |
| } | |
| // IUniswapV2PairApproval represents a Approval event raised by the IUniswapV2Pair contract. | |
| type IUniswapV2PairApproval struct { | |
| Owner common.Address | |
| Spender common.Address | |
| Value *big.Int | |
| Raw types.Log // Blockchain specific contextual infos | |
| } | |
| // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. | |
| // | |
| // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) | |
| func (_IUniswapV2Pair *IUniswapV2PairFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*IUniswapV2PairApprovalIterator, error) { | |
| var ownerRule []interface{} | |
| for _, ownerItem := range owner { | |
| ownerRule = append(ownerRule, ownerItem) | |
| } | |
| var spenderRule []interface{} | |
| for _, spenderItem := range spender { | |
| spenderRule = append(spenderRule, spenderItem) | |
| } | |
| logs, sub, err := _IUniswapV2Pair.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2PairApprovalIterator{contract: _IUniswapV2Pair.contract, event: "Approval", logs: logs, sub: sub}, nil | |
| } | |
| // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. | |
| // | |
| // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) | |
| func (_IUniswapV2Pair *IUniswapV2PairFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IUniswapV2PairApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { | |
| var ownerRule []interface{} | |
| for _, ownerItem := range owner { | |
| ownerRule = append(ownerRule, ownerItem) | |
| } | |
| var spenderRule []interface{} | |
| for _, spenderItem := range spender { | |
| spenderRule = append(spenderRule, spenderItem) | |
| } | |
| logs, sub, err := _IUniswapV2Pair.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) | |
| 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(IUniswapV2PairApproval) | |
| if err := _IUniswapV2Pair.contract.UnpackLog(event, "Approval", 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 | |
| } | |
| // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. | |
| // | |
| // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) | |
| func (_IUniswapV2Pair *IUniswapV2PairFilterer) ParseApproval(log types.Log) (*IUniswapV2PairApproval, error) { | |
| event := new(IUniswapV2PairApproval) | |
| if err := _IUniswapV2Pair.contract.UnpackLog(event, "Approval", log); err != nil { | |
| return nil, err | |
| } | |
| return event, nil | |
| } | |
| // IUniswapV2PairBurnIterator is returned from FilterBurn and is used to iterate over the raw logs and unpacked data for Burn events raised by the IUniswapV2Pair contract. | |
| type IUniswapV2PairBurnIterator struct { | |
| Event *IUniswapV2PairBurn // 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 *IUniswapV2PairBurnIterator) 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(IUniswapV2PairBurn) | |
| 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(IUniswapV2PairBurn) | |
| 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 *IUniswapV2PairBurnIterator) Error() error { | |
| return it.fail | |
| } | |
| // Close terminates the iteration process, releasing any pending underlying | |
| // resources. | |
| func (it *IUniswapV2PairBurnIterator) Close() error { | |
| it.sub.Unsubscribe() | |
| return nil | |
| } | |
| // IUniswapV2PairBurn represents a Burn event raised by the IUniswapV2Pair contract. | |
| type IUniswapV2PairBurn struct { | |
| Sender common.Address | |
| Amount0 *big.Int | |
| Amount1 *big.Int | |
| To common.Address | |
| Raw types.Log // Blockchain specific contextual infos | |
| } | |
| // FilterBurn is a free log retrieval operation binding the contract event 0xdccd412f0b1252819cb1fd330b93224ca42612892bb3f4f789976e6d81936496. | |
| // | |
| // Solidity: event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to) | |
| func (_IUniswapV2Pair *IUniswapV2PairFilterer) FilterBurn(opts *bind.FilterOpts, sender []common.Address, to []common.Address) (*IUniswapV2PairBurnIterator, error) { | |
| var senderRule []interface{} | |
| for _, senderItem := range sender { | |
| senderRule = append(senderRule, senderItem) | |
| } | |
| var toRule []interface{} | |
| for _, toItem := range to { | |
| toRule = append(toRule, toItem) | |
| } | |
| logs, sub, err := _IUniswapV2Pair.contract.FilterLogs(opts, "Burn", senderRule, toRule) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2PairBurnIterator{contract: _IUniswapV2Pair.contract, event: "Burn", logs: logs, sub: sub}, nil | |
| } | |
| // WatchBurn is a free log subscription operation binding the contract event 0xdccd412f0b1252819cb1fd330b93224ca42612892bb3f4f789976e6d81936496. | |
| // | |
| // Solidity: event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to) | |
| func (_IUniswapV2Pair *IUniswapV2PairFilterer) WatchBurn(opts *bind.WatchOpts, sink chan<- *IUniswapV2PairBurn, sender []common.Address, to []common.Address) (event.Subscription, error) { | |
| var senderRule []interface{} | |
| for _, senderItem := range sender { | |
| senderRule = append(senderRule, senderItem) | |
| } | |
| var toRule []interface{} | |
| for _, toItem := range to { | |
| toRule = append(toRule, toItem) | |
| } | |
| logs, sub, err := _IUniswapV2Pair.contract.WatchLogs(opts, "Burn", senderRule, toRule) | |
| 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(IUniswapV2PairBurn) | |
| if err := _IUniswapV2Pair.contract.UnpackLog(event, "Burn", 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 | |
| } | |
| // ParseBurn is a log parse operation binding the contract event 0xdccd412f0b1252819cb1fd330b93224ca42612892bb3f4f789976e6d81936496. | |
| // | |
| // Solidity: event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to) | |
| func (_IUniswapV2Pair *IUniswapV2PairFilterer) ParseBurn(log types.Log) (*IUniswapV2PairBurn, error) { | |
| event := new(IUniswapV2PairBurn) | |
| if err := _IUniswapV2Pair.contract.UnpackLog(event, "Burn", log); err != nil { | |
| return nil, err | |
| } | |
| return event, nil | |
| } | |
| // IUniswapV2PairMintIterator is returned from FilterMint and is used to iterate over the raw logs and unpacked data for Mint events raised by the IUniswapV2Pair contract. | |
| type IUniswapV2PairMintIterator struct { | |
| Event *IUniswapV2PairMint // 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 *IUniswapV2PairMintIterator) 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(IUniswapV2PairMint) | |
| 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(IUniswapV2PairMint) | |
| 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 *IUniswapV2PairMintIterator) Error() error { | |
| return it.fail | |
| } | |
| // Close terminates the iteration process, releasing any pending underlying | |
| // resources. | |
| func (it *IUniswapV2PairMintIterator) Close() error { | |
| it.sub.Unsubscribe() | |
| return nil | |
| } | |
| // IUniswapV2PairMint represents a Mint event raised by the IUniswapV2Pair contract. | |
| type IUniswapV2PairMint struct { | |
| Sender common.Address | |
| Amount0 *big.Int | |
| Amount1 *big.Int | |
| Raw types.Log // Blockchain specific contextual infos | |
| } | |
| // FilterMint is a free log retrieval operation binding the contract event 0x4c209b5fc8ad50758f13e2e1088ba56a560dff690a1c6fef26394f4c03821c4f. | |
| // | |
| // Solidity: event Mint(address indexed sender, uint256 amount0, uint256 amount1) | |
| func (_IUniswapV2Pair *IUniswapV2PairFilterer) FilterMint(opts *bind.FilterOpts, sender []common.Address) (*IUniswapV2PairMintIterator, error) { | |
| var senderRule []interface{} | |
| for _, senderItem := range sender { | |
| senderRule = append(senderRule, senderItem) | |
| } | |
| logs, sub, err := _IUniswapV2Pair.contract.FilterLogs(opts, "Mint", senderRule) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2PairMintIterator{contract: _IUniswapV2Pair.contract, event: "Mint", logs: logs, sub: sub}, nil | |
| } | |
| // WatchMint is a free log subscription operation binding the contract event 0x4c209b5fc8ad50758f13e2e1088ba56a560dff690a1c6fef26394f4c03821c4f. | |
| // | |
| // Solidity: event Mint(address indexed sender, uint256 amount0, uint256 amount1) | |
| func (_IUniswapV2Pair *IUniswapV2PairFilterer) WatchMint(opts *bind.WatchOpts, sink chan<- *IUniswapV2PairMint, sender []common.Address) (event.Subscription, error) { | |
| var senderRule []interface{} | |
| for _, senderItem := range sender { | |
| senderRule = append(senderRule, senderItem) | |
| } | |
| logs, sub, err := _IUniswapV2Pair.contract.WatchLogs(opts, "Mint", senderRule) | |
| 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(IUniswapV2PairMint) | |
| if err := _IUniswapV2Pair.contract.UnpackLog(event, "Mint", 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 | |
| } | |
| // ParseMint is a log parse operation binding the contract event 0x4c209b5fc8ad50758f13e2e1088ba56a560dff690a1c6fef26394f4c03821c4f. | |
| // | |
| // Solidity: event Mint(address indexed sender, uint256 amount0, uint256 amount1) | |
| func (_IUniswapV2Pair *IUniswapV2PairFilterer) ParseMint(log types.Log) (*IUniswapV2PairMint, error) { | |
| event := new(IUniswapV2PairMint) | |
| if err := _IUniswapV2Pair.contract.UnpackLog(event, "Mint", log); err != nil { | |
| return nil, err | |
| } | |
| return event, nil | |
| } | |
| // IUniswapV2PairSwapIterator is returned from FilterSwap and is used to iterate over the raw logs and unpacked data for Swap events raised by the IUniswapV2Pair contract. | |
| type IUniswapV2PairSwapIterator struct { | |
| Event *IUniswapV2PairSwap // 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 *IUniswapV2PairSwapIterator) 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(IUniswapV2PairSwap) | |
| 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(IUniswapV2PairSwap) | |
| 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 *IUniswapV2PairSwapIterator) Error() error { | |
| return it.fail | |
| } | |
| // Close terminates the iteration process, releasing any pending underlying | |
| // resources. | |
| func (it *IUniswapV2PairSwapIterator) Close() error { | |
| it.sub.Unsubscribe() | |
| return nil | |
| } | |
| // IUniswapV2PairSwap represents a Swap event raised by the IUniswapV2Pair contract. | |
| type IUniswapV2PairSwap struct { | |
| Sender common.Address | |
| Amount0In *big.Int | |
| Amount1In *big.Int | |
| Amount0Out *big.Int | |
| Amount1Out *big.Int | |
| To common.Address | |
| Raw types.Log // Blockchain specific contextual infos | |
| } | |
| // FilterSwap is a free log retrieval operation binding the contract event 0xd78ad95fa46c994b6551d0da85fc275fe613ce37657fb8d5e3d130840159d822. | |
| // | |
| // Solidity: event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to) | |
| func (_IUniswapV2Pair *IUniswapV2PairFilterer) FilterSwap(opts *bind.FilterOpts, sender []common.Address, to []common.Address) (*IUniswapV2PairSwapIterator, error) { | |
| var senderRule []interface{} | |
| for _, senderItem := range sender { | |
| senderRule = append(senderRule, senderItem) | |
| } | |
| var toRule []interface{} | |
| for _, toItem := range to { | |
| toRule = append(toRule, toItem) | |
| } | |
| logs, sub, err := _IUniswapV2Pair.contract.FilterLogs(opts, "Swap", senderRule, toRule) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2PairSwapIterator{contract: _IUniswapV2Pair.contract, event: "Swap", logs: logs, sub: sub}, nil | |
| } | |
| // WatchSwap is a free log subscription operation binding the contract event 0xd78ad95fa46c994b6551d0da85fc275fe613ce37657fb8d5e3d130840159d822. | |
| // | |
| // Solidity: event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to) | |
| func (_IUniswapV2Pair *IUniswapV2PairFilterer) WatchSwap(opts *bind.WatchOpts, sink chan<- *IUniswapV2PairSwap, sender []common.Address, to []common.Address) (event.Subscription, error) { | |
| var senderRule []interface{} | |
| for _, senderItem := range sender { | |
| senderRule = append(senderRule, senderItem) | |
| } | |
| var toRule []interface{} | |
| for _, toItem := range to { | |
| toRule = append(toRule, toItem) | |
| } | |
| logs, sub, err := _IUniswapV2Pair.contract.WatchLogs(opts, "Swap", senderRule, toRule) | |
| 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(IUniswapV2PairSwap) | |
| if err := _IUniswapV2Pair.contract.UnpackLog(event, "Swap", 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 | |
| } | |
| // ParseSwap is a log parse operation binding the contract event 0xd78ad95fa46c994b6551d0da85fc275fe613ce37657fb8d5e3d130840159d822. | |
| // | |
| // Solidity: event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to) | |
| func (_IUniswapV2Pair *IUniswapV2PairFilterer) ParseSwap(log types.Log) (*IUniswapV2PairSwap, error) { | |
| event := new(IUniswapV2PairSwap) | |
| if err := _IUniswapV2Pair.contract.UnpackLog(event, "Swap", log); err != nil { | |
| return nil, err | |
| } | |
| return event, nil | |
| } | |
| // IUniswapV2PairSyncIterator is returned from FilterSync and is used to iterate over the raw logs and unpacked data for Sync events raised by the IUniswapV2Pair contract. | |
| type IUniswapV2PairSyncIterator struct { | |
| Event *IUniswapV2PairSync // 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 *IUniswapV2PairSyncIterator) 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(IUniswapV2PairSync) | |
| 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(IUniswapV2PairSync) | |
| 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 *IUniswapV2PairSyncIterator) Error() error { | |
| return it.fail | |
| } | |
| // Close terminates the iteration process, releasing any pending underlying | |
| // resources. | |
| func (it *IUniswapV2PairSyncIterator) Close() error { | |
| it.sub.Unsubscribe() | |
| return nil | |
| } | |
| // IUniswapV2PairSync represents a Sync event raised by the IUniswapV2Pair contract. | |
| type IUniswapV2PairSync struct { | |
| Reserve0 *big.Int | |
| Reserve1 *big.Int | |
| Raw types.Log // Blockchain specific contextual infos | |
| } | |
| // FilterSync is a free log retrieval operation binding the contract event 0x1c411e9a96e071241c2f21f7726b17ae89e3cab4c78be50e062b03a9fffbbad1. | |
| // | |
| // Solidity: event Sync(uint112 reserve0, uint112 reserve1) | |
| func (_IUniswapV2Pair *IUniswapV2PairFilterer) FilterSync(opts *bind.FilterOpts) (*IUniswapV2PairSyncIterator, error) { | |
| logs, sub, err := _IUniswapV2Pair.contract.FilterLogs(opts, "Sync") | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2PairSyncIterator{contract: _IUniswapV2Pair.contract, event: "Sync", logs: logs, sub: sub}, nil | |
| } | |
| // WatchSync is a free log subscription operation binding the contract event 0x1c411e9a96e071241c2f21f7726b17ae89e3cab4c78be50e062b03a9fffbbad1. | |
| // | |
| // Solidity: event Sync(uint112 reserve0, uint112 reserve1) | |
| func (_IUniswapV2Pair *IUniswapV2PairFilterer) WatchSync(opts *bind.WatchOpts, sink chan<- *IUniswapV2PairSync) (event.Subscription, error) { | |
| logs, sub, err := _IUniswapV2Pair.contract.WatchLogs(opts, "Sync") | |
| 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(IUniswapV2PairSync) | |
| if err := _IUniswapV2Pair.contract.UnpackLog(event, "Sync", 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 | |
| } | |
| // ParseSync is a log parse operation binding the contract event 0x1c411e9a96e071241c2f21f7726b17ae89e3cab4c78be50e062b03a9fffbbad1. | |
| // | |
| // Solidity: event Sync(uint112 reserve0, uint112 reserve1) | |
| func (_IUniswapV2Pair *IUniswapV2PairFilterer) ParseSync(log types.Log) (*IUniswapV2PairSync, error) { | |
| event := new(IUniswapV2PairSync) | |
| if err := _IUniswapV2Pair.contract.UnpackLog(event, "Sync", log); err != nil { | |
| return nil, err | |
| } | |
| return event, nil | |
| } | |
| // IUniswapV2PairTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the IUniswapV2Pair contract. | |
| type IUniswapV2PairTransferIterator struct { | |
| Event *IUniswapV2PairTransfer // 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 *IUniswapV2PairTransferIterator) 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(IUniswapV2PairTransfer) | |
| 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(IUniswapV2PairTransfer) | |
| 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 *IUniswapV2PairTransferIterator) Error() error { | |
| return it.fail | |
| } | |
| // Close terminates the iteration process, releasing any pending underlying | |
| // resources. | |
| func (it *IUniswapV2PairTransferIterator) Close() error { | |
| it.sub.Unsubscribe() | |
| return nil | |
| } | |
| // IUniswapV2PairTransfer represents a Transfer event raised by the IUniswapV2Pair contract. | |
| type IUniswapV2PairTransfer struct { | |
| From common.Address | |
| To common.Address | |
| Value *big.Int | |
| Raw types.Log // Blockchain specific contextual infos | |
| } | |
| // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. | |
| // | |
| // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) | |
| func (_IUniswapV2Pair *IUniswapV2PairFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*IUniswapV2PairTransferIterator, error) { | |
| var fromRule []interface{} | |
| for _, fromItem := range from { | |
| fromRule = append(fromRule, fromItem) | |
| } | |
| var toRule []interface{} | |
| for _, toItem := range to { | |
| toRule = append(toRule, toItem) | |
| } | |
| logs, sub, err := _IUniswapV2Pair.contract.FilterLogs(opts, "Transfer", fromRule, toRule) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &IUniswapV2PairTransferIterator{contract: _IUniswapV2Pair.contract, event: "Transfer", logs: logs, sub: sub}, nil | |
| } | |
| // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. | |
| // | |
| // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) | |
| func (_IUniswapV2Pair *IUniswapV2PairFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IUniswapV2PairTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { | |
| var fromRule []interface{} | |
| for _, fromItem := range from { | |
| fromRule = append(fromRule, fromItem) | |
| } | |
| var toRule []interface{} | |
| for _, toItem := range to { | |
| toRule = append(toRule, toItem) | |
| } | |
| logs, sub, err := _IUniswapV2Pair.contract.WatchLogs(opts, "Transfer", fromRule, toRule) | |
| 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(IUniswapV2PairTransfer) | |
| if err := _IUniswapV2Pair.contract.UnpackLog(event, "Transfer", 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 | |
| } | |
| // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. | |
| // | |
| // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) | |
| func (_IUniswapV2Pair *IUniswapV2PairFilterer) ParseTransfer(log types.Log) (*IUniswapV2PairTransfer, error) { | |
| event := new(IUniswapV2PairTransfer) | |
| if err := _IUniswapV2Pair.contract.UnpackLog(event, "Transfer", log); err != nil { | |
| return nil, err | |
| } | |
| return event, nil | |
| } | |
| // MathABI is the input ABI used to generate the binding from. | |
| const MathABI = "[]" | |
| // MathBin is the compiled bytecode used for deploying new contracts. | |
| var MathBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a7231582081e9ccd423fcc993f0e81d159cb672b6a490c6b351a9573a5320d62398367f1564736f6c63430005100032" | |
| // DeployMath deploys a new Ethereum contract, binding an instance of Math to it. | |
| func DeployMath(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Math, error) { | |
| parsed, err := abi.JSON(strings.NewReader(MathABI)) | |
| if err != nil { | |
| return common.Address{}, nil, nil, err | |
| } | |
| address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(MathBin), backend) | |
| if err != nil { | |
| return common.Address{}, nil, nil, err | |
| } | |
| return address, tx, &Math{MathCaller: MathCaller{contract: contract}, MathTransactor: MathTransactor{contract: contract}, MathFilterer: MathFilterer{contract: contract}}, nil | |
| } | |
| // Math is an auto generated Go binding around an Ethereum contract. | |
| type Math struct { | |
| MathCaller // Read-only binding to the contract | |
| MathTransactor // Write-only binding to the contract | |
| MathFilterer // Log filterer for contract events | |
| } | |
| // MathCaller is an auto generated read-only Go binding around an Ethereum contract. | |
| type MathCaller struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // MathTransactor is an auto generated write-only Go binding around an Ethereum contract. | |
| type MathTransactor struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // MathFilterer is an auto generated log filtering Go binding around an Ethereum contract events. | |
| type MathFilterer struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // MathSession is an auto generated Go binding around an Ethereum contract, | |
| // with pre-set call and transact options. | |
| type MathSession struct { | |
| Contract *Math // 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 | |
| } | |
| // MathCallerSession is an auto generated read-only Go binding around an Ethereum contract, | |
| // with pre-set call options. | |
| type MathCallerSession struct { | |
| Contract *MathCaller // Generic contract caller binding to set the session for | |
| CallOpts bind.CallOpts // Call options to use throughout this session | |
| } | |
| // MathTransactorSession is an auto generated write-only Go binding around an Ethereum contract, | |
| // with pre-set transact options. | |
| type MathTransactorSession struct { | |
| Contract *MathTransactor // Generic contract transactor binding to set the session for | |
| TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session | |
| } | |
| // MathRaw is an auto generated low-level Go binding around an Ethereum contract. | |
| type MathRaw struct { | |
| Contract *Math // Generic contract binding to access the raw methods on | |
| } | |
| // MathCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. | |
| type MathCallerRaw struct { | |
| Contract *MathCaller // Generic read-only contract binding to access the raw methods on | |
| } | |
| // MathTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. | |
| type MathTransactorRaw struct { | |
| Contract *MathTransactor // Generic write-only contract binding to access the raw methods on | |
| } | |
| // NewMath creates a new instance of Math, bound to a specific deployed contract. | |
| func NewMath(address common.Address, backend bind.ContractBackend) (*Math, error) { | |
| contract, err := bindMath(address, backend, backend, backend) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &Math{MathCaller: MathCaller{contract: contract}, MathTransactor: MathTransactor{contract: contract}, MathFilterer: MathFilterer{contract: contract}}, nil | |
| } | |
| // NewMathCaller creates a new read-only instance of Math, bound to a specific deployed contract. | |
| func NewMathCaller(address common.Address, caller bind.ContractCaller) (*MathCaller, error) { | |
| contract, err := bindMath(address, caller, nil, nil) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &MathCaller{contract: contract}, nil | |
| } | |
| // NewMathTransactor creates a new write-only instance of Math, bound to a specific deployed contract. | |
| func NewMathTransactor(address common.Address, transactor bind.ContractTransactor) (*MathTransactor, error) { | |
| contract, err := bindMath(address, nil, transactor, nil) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &MathTransactor{contract: contract}, nil | |
| } | |
| // NewMathFilterer creates a new log filterer instance of Math, bound to a specific deployed contract. | |
| func NewMathFilterer(address common.Address, filterer bind.ContractFilterer) (*MathFilterer, error) { | |
| contract, err := bindMath(address, nil, nil, filterer) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &MathFilterer{contract: contract}, nil | |
| } | |
| // bindMath binds a generic wrapper to an already deployed contract. | |
| func bindMath(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { | |
| parsed, err := abi.JSON(strings.NewReader(MathABI)) | |
| 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 (_Math *MathRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { | |
| return _Math.Contract.MathCaller.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 (_Math *MathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { | |
| return _Math.Contract.MathTransactor.contract.Transfer(opts) | |
| } | |
| // Transact invokes the (paid) contract method with params as input values. | |
| func (_Math *MathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { | |
| return _Math.Contract.MathTransactor.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 (_Math *MathCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { | |
| return _Math.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 (_Math *MathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { | |
| return _Math.Contract.contract.Transfer(opts) | |
| } | |
| // Transact invokes the (paid) contract method with params as input values. | |
| func (_Math *MathTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { | |
| return _Math.Contract.contract.Transact(opts, method, params...) | |
| } | |
| // SafeMathABI is the input ABI used to generate the binding from. | |
| const SafeMathABI = "[]" | |
| // SafeMathBin is the compiled bytecode used for deploying new contracts. | |
| var SafeMathBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a723158201b56d92138da4c727cf28d3f157c6cd2b756969e313f68004fe81129430604a164736f6c63430005100032" | |
| // DeploySafeMath deploys a new Ethereum contract, binding an instance of SafeMath to it. | |
| func DeploySafeMath(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SafeMath, error) { | |
| parsed, err := abi.JSON(strings.NewReader(SafeMathABI)) | |
| if err != nil { | |
| return common.Address{}, nil, nil, err | |
| } | |
| address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(SafeMathBin), backend) | |
| if err != nil { | |
| return common.Address{}, nil, nil, err | |
| } | |
| return address, tx, &SafeMath{SafeMathCaller: SafeMathCaller{contract: contract}, SafeMathTransactor: SafeMathTransactor{contract: contract}, SafeMathFilterer: SafeMathFilterer{contract: contract}}, nil | |
| } | |
| // SafeMath is an auto generated Go binding around an Ethereum contract. | |
| type SafeMath struct { | |
| SafeMathCaller // Read-only binding to the contract | |
| SafeMathTransactor // Write-only binding to the contract | |
| SafeMathFilterer // Log filterer for contract events | |
| } | |
| // SafeMathCaller is an auto generated read-only Go binding around an Ethereum contract. | |
| type SafeMathCaller struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // SafeMathTransactor is an auto generated write-only Go binding around an Ethereum contract. | |
| type SafeMathTransactor struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // SafeMathFilterer is an auto generated log filtering Go binding around an Ethereum contract events. | |
| type SafeMathFilterer struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // SafeMathSession is an auto generated Go binding around an Ethereum contract, | |
| // with pre-set call and transact options. | |
| type SafeMathSession struct { | |
| Contract *SafeMath // 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 | |
| } | |
| // SafeMathCallerSession is an auto generated read-only Go binding around an Ethereum contract, | |
| // with pre-set call options. | |
| type SafeMathCallerSession struct { | |
| Contract *SafeMathCaller // Generic contract caller binding to set the session for | |
| CallOpts bind.CallOpts // Call options to use throughout this session | |
| } | |
| // SafeMathTransactorSession is an auto generated write-only Go binding around an Ethereum contract, | |
| // with pre-set transact options. | |
| type SafeMathTransactorSession struct { | |
| Contract *SafeMathTransactor // Generic contract transactor binding to set the session for | |
| TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session | |
| } | |
| // SafeMathRaw is an auto generated low-level Go binding around an Ethereum contract. | |
| type SafeMathRaw struct { | |
| Contract *SafeMath // Generic contract binding to access the raw methods on | |
| } | |
| // SafeMathCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. | |
| type SafeMathCallerRaw struct { | |
| Contract *SafeMathCaller // Generic read-only contract binding to access the raw methods on | |
| } | |
| // SafeMathTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. | |
| type SafeMathTransactorRaw struct { | |
| Contract *SafeMathTransactor // Generic write-only contract binding to access the raw methods on | |
| } | |
| // NewSafeMath creates a new instance of SafeMath, bound to a specific deployed contract. | |
| func NewSafeMath(address common.Address, backend bind.ContractBackend) (*SafeMath, error) { | |
| contract, err := bindSafeMath(address, backend, backend, backend) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &SafeMath{SafeMathCaller: SafeMathCaller{contract: contract}, SafeMathTransactor: SafeMathTransactor{contract: contract}, SafeMathFilterer: SafeMathFilterer{contract: contract}}, nil | |
| } | |
| // NewSafeMathCaller creates a new read-only instance of SafeMath, bound to a specific deployed contract. | |
| func NewSafeMathCaller(address common.Address, caller bind.ContractCaller) (*SafeMathCaller, error) { | |
| contract, err := bindSafeMath(address, caller, nil, nil) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &SafeMathCaller{contract: contract}, nil | |
| } | |
| // NewSafeMathTransactor creates a new write-only instance of SafeMath, bound to a specific deployed contract. | |
| func NewSafeMathTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeMathTransactor, error) { | |
| contract, err := bindSafeMath(address, nil, transactor, nil) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &SafeMathTransactor{contract: contract}, nil | |
| } | |
| // NewSafeMathFilterer creates a new log filterer instance of SafeMath, bound to a specific deployed contract. | |
| func NewSafeMathFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeMathFilterer, error) { | |
| contract, err := bindSafeMath(address, nil, nil, filterer) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &SafeMathFilterer{contract: contract}, nil | |
| } | |
| // bindSafeMath binds a generic wrapper to an already deployed contract. | |
| func bindSafeMath(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { | |
| parsed, err := abi.JSON(strings.NewReader(SafeMathABI)) | |
| 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 (_SafeMath *SafeMathRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { | |
| return _SafeMath.Contract.SafeMathCaller.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 (_SafeMath *SafeMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { | |
| return _SafeMath.Contract.SafeMathTransactor.contract.Transfer(opts) | |
| } | |
| // Transact invokes the (paid) contract method with params as input values. | |
| func (_SafeMath *SafeMathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { | |
| return _SafeMath.Contract.SafeMathTransactor.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 (_SafeMath *SafeMathCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { | |
| return _SafeMath.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 (_SafeMath *SafeMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { | |
| return _SafeMath.Contract.contract.Transfer(opts) | |
| } | |
| // Transact invokes the (paid) contract method with params as input values. | |
| func (_SafeMath *SafeMathTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { | |
| return _SafeMath.Contract.contract.Transact(opts, method, params...) | |
| } | |
| // UQ112x112ABI is the input ABI used to generate the binding from. | |
| const UQ112x112ABI = "[]" | |
| // UQ112x112Bin is the compiled bytecode used for deploying new contracts. | |
| var UQ112x112Bin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a7231582092286a07eb4dc3dcc7db92fac7f6fd2accd5742e96546960fd1cfacbf1561f2864736f6c63430005100032" | |
| // DeployUQ112x112 deploys a new Ethereum contract, binding an instance of UQ112x112 to it. | |
| func DeployUQ112x112(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *UQ112x112, error) { | |
| parsed, err := abi.JSON(strings.NewReader(UQ112x112ABI)) | |
| if err != nil { | |
| return common.Address{}, nil, nil, err | |
| } | |
| address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(UQ112x112Bin), backend) | |
| if err != nil { | |
| return common.Address{}, nil, nil, err | |
| } | |
| return address, tx, &UQ112x112{UQ112x112Caller: UQ112x112Caller{contract: contract}, UQ112x112Transactor: UQ112x112Transactor{contract: contract}, UQ112x112Filterer: UQ112x112Filterer{contract: contract}}, nil | |
| } | |
| // UQ112x112 is an auto generated Go binding around an Ethereum contract. | |
| type UQ112x112 struct { | |
| UQ112x112Caller // Read-only binding to the contract | |
| UQ112x112Transactor // Write-only binding to the contract | |
| UQ112x112Filterer // Log filterer for contract events | |
| } | |
| // UQ112x112Caller is an auto generated read-only Go binding around an Ethereum contract. | |
| type UQ112x112Caller struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // UQ112x112Transactor is an auto generated write-only Go binding around an Ethereum contract. | |
| type UQ112x112Transactor struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // UQ112x112Filterer is an auto generated log filtering Go binding around an Ethereum contract events. | |
| type UQ112x112Filterer struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // UQ112x112Session is an auto generated Go binding around an Ethereum contract, | |
| // with pre-set call and transact options. | |
| type UQ112x112Session struct { | |
| Contract *UQ112x112 // 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 | |
| } | |
| // UQ112x112CallerSession is an auto generated read-only Go binding around an Ethereum contract, | |
| // with pre-set call options. | |
| type UQ112x112CallerSession struct { | |
| Contract *UQ112x112Caller // Generic contract caller binding to set the session for | |
| CallOpts bind.CallOpts // Call options to use throughout this session | |
| } | |
| // UQ112x112TransactorSession is an auto generated write-only Go binding around an Ethereum contract, | |
| // with pre-set transact options. | |
| type UQ112x112TransactorSession struct { | |
| Contract *UQ112x112Transactor // Generic contract transactor binding to set the session for | |
| TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session | |
| } | |
| // UQ112x112Raw is an auto generated low-level Go binding around an Ethereum contract. | |
| type UQ112x112Raw struct { | |
| Contract *UQ112x112 // Generic contract binding to access the raw methods on | |
| } | |
| // UQ112x112CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. | |
| type UQ112x112CallerRaw struct { | |
| Contract *UQ112x112Caller // Generic read-only contract binding to access the raw methods on | |
| } | |
| // UQ112x112TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. | |
| type UQ112x112TransactorRaw struct { | |
| Contract *UQ112x112Transactor // Generic write-only contract binding to access the raw methods on | |
| } | |
| // NewUQ112x112 creates a new instance of UQ112x112, bound to a specific deployed contract. | |
| func NewUQ112x112(address common.Address, backend bind.ContractBackend) (*UQ112x112, error) { | |
| contract, err := bindUQ112x112(address, backend, backend, backend) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &UQ112x112{UQ112x112Caller: UQ112x112Caller{contract: contract}, UQ112x112Transactor: UQ112x112Transactor{contract: contract}, UQ112x112Filterer: UQ112x112Filterer{contract: contract}}, nil | |
| } | |
| // NewUQ112x112Caller creates a new read-only instance of UQ112x112, bound to a specific deployed contract. | |
| func NewUQ112x112Caller(address common.Address, caller bind.ContractCaller) (*UQ112x112Caller, error) { | |
| contract, err := bindUQ112x112(address, caller, nil, nil) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &UQ112x112Caller{contract: contract}, nil | |
| } | |
| // NewUQ112x112Transactor creates a new write-only instance of UQ112x112, bound to a specific deployed contract. | |
| func NewUQ112x112Transactor(address common.Address, transactor bind.ContractTransactor) (*UQ112x112Transactor, error) { | |
| contract, err := bindUQ112x112(address, nil, transactor, nil) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &UQ112x112Transactor{contract: contract}, nil | |
| } | |
| // NewUQ112x112Filterer creates a new log filterer instance of UQ112x112, bound to a specific deployed contract. | |
| func NewUQ112x112Filterer(address common.Address, filterer bind.ContractFilterer) (*UQ112x112Filterer, error) { | |
| contract, err := bindUQ112x112(address, nil, nil, filterer) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &UQ112x112Filterer{contract: contract}, nil | |
| } | |
| // bindUQ112x112 binds a generic wrapper to an already deployed contract. | |
| func bindUQ112x112(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { | |
| parsed, err := abi.JSON(strings.NewReader(UQ112x112ABI)) | |
| 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 (_UQ112x112 *UQ112x112Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { | |
| return _UQ112x112.Contract.UQ112x112Caller.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 (_UQ112x112 *UQ112x112Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { | |
| return _UQ112x112.Contract.UQ112x112Transactor.contract.Transfer(opts) | |
| } | |
| // Transact invokes the (paid) contract method with params as input values. | |
| func (_UQ112x112 *UQ112x112Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { | |
| return _UQ112x112.Contract.UQ112x112Transactor.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 (_UQ112x112 *UQ112x112CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { | |
| return _UQ112x112.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 (_UQ112x112 *UQ112x112TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { | |
| return _UQ112x112.Contract.contract.Transfer(opts) | |
| } | |
| // Transact invokes the (paid) contract method with params as input values. | |
| func (_UQ112x112 *UQ112x112TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { | |
| return _UQ112x112.Contract.contract.Transact(opts, method, params...) | |
| } | |
| // UniswapV2ERC20ABI is the input ABI used to generate the binding from. | |
| const UniswapV2ERC20ABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[],\"name\":\"DOMAIN_SEPARATOR\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"PERMIT_TYPEHASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"nonces\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"permit\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" | |
| // UniswapV2ERC20FuncSigs maps the 4-byte function signature to its string representation. | |
| var UniswapV2ERC20FuncSigs = map[string]string{ | |
| "3644e515": "DOMAIN_SEPARATOR()", | |
| "30adf81f": "PERMIT_TYPEHASH()", | |
| "dd62ed3e": "allowance(address,address)", | |
| "095ea7b3": "approve(address,uint256)", | |
| "70a08231": "balanceOf(address)", | |
| "313ce567": "decimals()", | |
| "06fdde03": "name()", | |
| "7ecebe00": "nonces(address)", | |
| "d505accf": "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)", | |
| "95d89b41": "symbol()", | |
| "18160ddd": "totalSupply()", | |
| "a9059cbb": "transfer(address,uint256)", | |
| "23b872dd": "transferFrom(address,address,uint256)", | |
| } | |
| // UniswapV2ERC20Bin is the compiled bytecode used for deploying new contracts. | |
| var UniswapV2ERC20Bin = "0x608060405234801561001057600080fd5b50604051469080605261096c8239604080519182900360520182208282018252600a8352692ab734b9bbb0b8102b1960b11b6020938401528151808301835260018152603160f81b908401528151808401919091527fbfcc8ef98ffbf7b6c3fec7bf5185b566b9863e35a9d83acd49ad6824b5969738818301527fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6606082015260808101949094523060a0808601919091528151808603909101815260c0909401905282519201919091206003555061087e806100ee6000396000f3fe608060405234801561001057600080fd5b50600436106100cf5760003560e01c80633644e5151161008c57806395d89b411161006657806395d89b411461025b578063a9059cbb14610263578063d505accf1461028f578063dd62ed3e146102e2576100cf565b80633644e5151461020757806370a082311461020f5780637ecebe0014610235576100cf565b806306fdde03146100d4578063095ea7b31461015157806318160ddd1461019157806323b872dd146101ab57806330adf81f146101e1578063313ce567146101e9575b600080fd5b6100dc610310565b6040805160208082528351818301528351919283929083019185019080838360005b838110156101165781810151838201526020016100fe565b50505050905090810190601f1680156101435780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b61017d6004803603604081101561016757600080fd5b506001600160a01b038135169060200135610336565b604080519115158252519081900360200190f35b61019961034d565b60408051918252519081900360200190f35b61017d600480360360608110156101c157600080fd5b506001600160a01b03813581169160208101359091169060400135610353565b6101996103ed565b6101f1610411565b6040805160ff9092168252519081900360200190f35b610199610416565b6101996004803603602081101561022557600080fd5b50356001600160a01b031661041c565b6101996004803603602081101561024b57600080fd5b50356001600160a01b031661042e565b6100dc610440565b61017d6004803603604081101561027957600080fd5b506001600160a01b038135169060200135610462565b6102e0600480360360e08110156102a557600080fd5b506001600160a01b03813581169160208101359091169060408101359060608101359060ff6080820135169060a08101359060c0013561046f565b005b610199600480360360408110156102f857600080fd5b506001600160a01b0381358116916020013516610671565b6040518060400160405280600a8152602001692ab734b9bbb0b8102b1960b11b81525081565b600061034333848461068e565b5060015b92915050565b60005481565b6001600160a01b0383166000908152600260209081526040808320338452909152812054600019146103d8576001600160a01b03841660009081526002602090815260408083203384529091529020546103b3908363ffffffff6106f016565b6001600160a01b03851660009081526002602090815260408083203384529091529020555b6103e3848484610740565b5060019392505050565b7f6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c981565b601281565b60035481565b60016020526000908152604090205481565b60046020526000908152604090205481565b604051806040016040528060068152602001652aa72496ab1960d11b81525081565b6000610343338484610740565b428410156104b9576040805162461bcd60e51b8152602060048201526012602482015271155b9a5cddd85c158c8e881156141254915160721b604482015290519081900360640190fd5b6003546001600160a01b0380891660008181526004602090815260408083208054600180820190925582517f6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c98186015280840196909652958d166060860152608085018c905260a085019590955260c08085018b90528151808603909101815260e08501825280519083012061190160f01b6101008601526101028501969096526101228085019690965280518085039096018652610142840180825286519683019690962095839052610162840180825286905260ff89166101828501526101a284018890526101c28401879052519193926101e280820193601f1981019281900390910190855afa1580156105d4573d6000803e3d6000fd5b5050604051601f1901519150506001600160a01b0381161580159061060a5750886001600160a01b0316816001600160a01b0316145b61065b576040805162461bcd60e51b815260206004820152601c60248201527f556e697377617056323a20494e56414c49445f5349474e415455524500000000604482015290519081900360640190fd5b61066689898961068e565b505050505050505050565b600260209081526000928352604080842090915290825290205481565b6001600160a01b03808416600081815260026020908152604080832094871680845294825291829020859055815185815291517f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9259281900390910190a3505050565b80820382811115610347576040805162461bcd60e51b815260206004820152601560248201527464732d6d6174682d7375622d756e646572666c6f7760581b604482015290519081900360640190fd5b6001600160a01b038316600090815260016020526040902054610769908263ffffffff6106f016565b6001600160a01b03808516600090815260016020526040808220939093559084168152205461079e908263ffffffff6107fa16565b6001600160a01b0380841660008181526001602090815260409182902094909455805185815290519193928716927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef92918290030190a3505050565b80820182811015610347576040805162461bcd60e51b815260206004820152601460248201527364732d6d6174682d6164642d6f766572666c6f7760601b604482015290519081900360640190fdfea265627a7a72315820a647d610a0f93ca152fea9a6ef958de39c95cf4e9e974a5a281889af9fae156564736f6c63430005100032454950373132446f6d61696e28737472696e67206e616d652c737472696e672076657273696f6e2c75696e7432353620636861696e49642c6164647265737320766572696679696e67436f6e747261637429" | |
| // DeployUniswapV2ERC20 deploys a new Ethereum contract, binding an instance of UniswapV2ERC20 to it. | |
| func DeployUniswapV2ERC20(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *UniswapV2ERC20, error) { | |
| parsed, err := abi.JSON(strings.NewReader(UniswapV2ERC20ABI)) | |
| if err != nil { | |
| return common.Address{}, nil, nil, err | |
| } | |
| address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(UniswapV2ERC20Bin), backend) | |
| if err != nil { | |
| return common.Address{}, nil, nil, err | |
| } | |
| return address, tx, &UniswapV2ERC20{UniswapV2ERC20Caller: UniswapV2ERC20Caller{contract: contract}, UniswapV2ERC20Transactor: UniswapV2ERC20Transactor{contract: contract}, UniswapV2ERC20Filterer: UniswapV2ERC20Filterer{contract: contract}}, nil | |
| } | |
| // UniswapV2ERC20 is an auto generated Go binding around an Ethereum contract. | |
| type UniswapV2ERC20 struct { | |
| UniswapV2ERC20Caller // Read-only binding to the contract | |
| UniswapV2ERC20Transactor // Write-only binding to the contract | |
| UniswapV2ERC20Filterer // Log filterer for contract events | |
| } | |
| // UniswapV2ERC20Caller is an auto generated read-only Go binding around an Ethereum contract. | |
| type UniswapV2ERC20Caller struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // UniswapV2ERC20Transactor is an auto generated write-only Go binding around an Ethereum contract. | |
| type UniswapV2ERC20Transactor struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // UniswapV2ERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. | |
| type UniswapV2ERC20Filterer struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // UniswapV2ERC20Session is an auto generated Go binding around an Ethereum contract, | |
| // with pre-set call and transact options. | |
| type UniswapV2ERC20Session struct { | |
| Contract *UniswapV2ERC20 // 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 | |
| } | |
| // UniswapV2ERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract, | |
| // with pre-set call options. | |
| type UniswapV2ERC20CallerSession struct { | |
| Contract *UniswapV2ERC20Caller // Generic contract caller binding to set the session for | |
| CallOpts bind.CallOpts // Call options to use throughout this session | |
| } | |
| // UniswapV2ERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, | |
| // with pre-set transact options. | |
| type UniswapV2ERC20TransactorSession struct { | |
| Contract *UniswapV2ERC20Transactor // Generic contract transactor binding to set the session for | |
| TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session | |
| } | |
| // UniswapV2ERC20Raw is an auto generated low-level Go binding around an Ethereum contract. | |
| type UniswapV2ERC20Raw struct { | |
| Contract *UniswapV2ERC20 // Generic contract binding to access the raw methods on | |
| } | |
| // UniswapV2ERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. | |
| type UniswapV2ERC20CallerRaw struct { | |
| Contract *UniswapV2ERC20Caller // Generic read-only contract binding to access the raw methods on | |
| } | |
| // UniswapV2ERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. | |
| type UniswapV2ERC20TransactorRaw struct { | |
| Contract *UniswapV2ERC20Transactor // Generic write-only contract binding to access the raw methods on | |
| } | |
| // NewUniswapV2ERC20 creates a new instance of UniswapV2ERC20, bound to a specific deployed contract. | |
| func NewUniswapV2ERC20(address common.Address, backend bind.ContractBackend) (*UniswapV2ERC20, error) { | |
| contract, err := bindUniswapV2ERC20(address, backend, backend, backend) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &UniswapV2ERC20{UniswapV2ERC20Caller: UniswapV2ERC20Caller{contract: contract}, UniswapV2ERC20Transactor: UniswapV2ERC20Transactor{contract: contract}, UniswapV2ERC20Filterer: UniswapV2ERC20Filterer{contract: contract}}, nil | |
| } | |
| // NewUniswapV2ERC20Caller creates a new read-only instance of UniswapV2ERC20, bound to a specific deployed contract. | |
| func NewUniswapV2ERC20Caller(address common.Address, caller bind.ContractCaller) (*UniswapV2ERC20Caller, error) { | |
| contract, err := bindUniswapV2ERC20(address, caller, nil, nil) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &UniswapV2ERC20Caller{contract: contract}, nil | |
| } | |
| // NewUniswapV2ERC20Transactor creates a new write-only instance of UniswapV2ERC20, bound to a specific deployed contract. | |
| func NewUniswapV2ERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*UniswapV2ERC20Transactor, error) { | |
| contract, err := bindUniswapV2ERC20(address, nil, transactor, nil) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &UniswapV2ERC20Transactor{contract: contract}, nil | |
| } | |
| // NewUniswapV2ERC20Filterer creates a new log filterer instance of UniswapV2ERC20, bound to a specific deployed contract. | |
| func NewUniswapV2ERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*UniswapV2ERC20Filterer, error) { | |
| contract, err := bindUniswapV2ERC20(address, nil, nil, filterer) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &UniswapV2ERC20Filterer{contract: contract}, nil | |
| } | |
| // bindUniswapV2ERC20 binds a generic wrapper to an already deployed contract. | |
| func bindUniswapV2ERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { | |
| parsed, err := abi.JSON(strings.NewReader(UniswapV2ERC20ABI)) | |
| 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 (_UniswapV2ERC20 *UniswapV2ERC20Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { | |
| return _UniswapV2ERC20.Contract.UniswapV2ERC20Caller.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 (_UniswapV2ERC20 *UniswapV2ERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { | |
| return _UniswapV2ERC20.Contract.UniswapV2ERC20Transactor.contract.Transfer(opts) | |
| } | |
| // Transact invokes the (paid) contract method with params as input values. | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { | |
| return _UniswapV2ERC20.Contract.UniswapV2ERC20Transactor.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 (_UniswapV2ERC20 *UniswapV2ERC20CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { | |
| return _UniswapV2ERC20.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 (_UniswapV2ERC20 *UniswapV2ERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { | |
| return _UniswapV2ERC20.Contract.contract.Transfer(opts) | |
| } | |
| // Transact invokes the (paid) contract method with params as input values. | |
| func (_UniswapV2ERC20 *UniswapV2ERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { | |
| return _UniswapV2ERC20.Contract.contract.Transact(opts, method, params...) | |
| } | |
| // DOMAINSEPARATOR is a free data retrieval call binding the contract method 0x3644e515. | |
| // | |
| // Solidity: function DOMAIN_SEPARATOR() view returns(bytes32) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Caller) DOMAINSEPARATOR(opts *bind.CallOpts) ([32]byte, error) { | |
| var out []interface{} | |
| err := _UniswapV2ERC20.contract.Call(opts, &out, "DOMAIN_SEPARATOR") | |
| if err != nil { | |
| return *new([32]byte), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) | |
| return out0, err | |
| } | |
| // DOMAINSEPARATOR is a free data retrieval call binding the contract method 0x3644e515. | |
| // | |
| // Solidity: function DOMAIN_SEPARATOR() view returns(bytes32) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Session) DOMAINSEPARATOR() ([32]byte, error) { | |
| return _UniswapV2ERC20.Contract.DOMAINSEPARATOR(&_UniswapV2ERC20.CallOpts) | |
| } | |
| // DOMAINSEPARATOR is a free data retrieval call binding the contract method 0x3644e515. | |
| // | |
| // Solidity: function DOMAIN_SEPARATOR() view returns(bytes32) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20CallerSession) DOMAINSEPARATOR() ([32]byte, error) { | |
| return _UniswapV2ERC20.Contract.DOMAINSEPARATOR(&_UniswapV2ERC20.CallOpts) | |
| } | |
| // PERMITTYPEHASH is a free data retrieval call binding the contract method 0x30adf81f. | |
| // | |
| // Solidity: function PERMIT_TYPEHASH() view returns(bytes32) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Caller) PERMITTYPEHASH(opts *bind.CallOpts) ([32]byte, error) { | |
| var out []interface{} | |
| err := _UniswapV2ERC20.contract.Call(opts, &out, "PERMIT_TYPEHASH") | |
| if err != nil { | |
| return *new([32]byte), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) | |
| return out0, err | |
| } | |
| // PERMITTYPEHASH is a free data retrieval call binding the contract method 0x30adf81f. | |
| // | |
| // Solidity: function PERMIT_TYPEHASH() view returns(bytes32) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Session) PERMITTYPEHASH() ([32]byte, error) { | |
| return _UniswapV2ERC20.Contract.PERMITTYPEHASH(&_UniswapV2ERC20.CallOpts) | |
| } | |
| // PERMITTYPEHASH is a free data retrieval call binding the contract method 0x30adf81f. | |
| // | |
| // Solidity: function PERMIT_TYPEHASH() view returns(bytes32) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20CallerSession) PERMITTYPEHASH() ([32]byte, error) { | |
| return _UniswapV2ERC20.Contract.PERMITTYPEHASH(&_UniswapV2ERC20.CallOpts) | |
| } | |
| // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. | |
| // | |
| // Solidity: function allowance(address , address ) view returns(uint256) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Caller) Allowance(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (*big.Int, error) { | |
| var out []interface{} | |
| err := _UniswapV2ERC20.contract.Call(opts, &out, "allowance", arg0, arg1) | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. | |
| // | |
| // Solidity: function allowance(address , address ) view returns(uint256) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Session) Allowance(arg0 common.Address, arg1 common.Address) (*big.Int, error) { | |
| return _UniswapV2ERC20.Contract.Allowance(&_UniswapV2ERC20.CallOpts, arg0, arg1) | |
| } | |
| // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. | |
| // | |
| // Solidity: function allowance(address , address ) view returns(uint256) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20CallerSession) Allowance(arg0 common.Address, arg1 common.Address) (*big.Int, error) { | |
| return _UniswapV2ERC20.Contract.Allowance(&_UniswapV2ERC20.CallOpts, arg0, arg1) | |
| } | |
| // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. | |
| // | |
| // Solidity: function balanceOf(address ) view returns(uint256) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Caller) BalanceOf(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { | |
| var out []interface{} | |
| err := _UniswapV2ERC20.contract.Call(opts, &out, "balanceOf", arg0) | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. | |
| // | |
| // Solidity: function balanceOf(address ) view returns(uint256) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Session) BalanceOf(arg0 common.Address) (*big.Int, error) { | |
| return _UniswapV2ERC20.Contract.BalanceOf(&_UniswapV2ERC20.CallOpts, arg0) | |
| } | |
| // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. | |
| // | |
| // Solidity: function balanceOf(address ) view returns(uint256) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20CallerSession) BalanceOf(arg0 common.Address) (*big.Int, error) { | |
| return _UniswapV2ERC20.Contract.BalanceOf(&_UniswapV2ERC20.CallOpts, arg0) | |
| } | |
| // Decimals is a free data retrieval call binding the contract method 0x313ce567. | |
| // | |
| // Solidity: function decimals() view returns(uint8) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Caller) Decimals(opts *bind.CallOpts) (uint8, error) { | |
| var out []interface{} | |
| err := _UniswapV2ERC20.contract.Call(opts, &out, "decimals") | |
| if err != nil { | |
| return *new(uint8), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) | |
| return out0, err | |
| } | |
| // Decimals is a free data retrieval call binding the contract method 0x313ce567. | |
| // | |
| // Solidity: function decimals() view returns(uint8) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Session) Decimals() (uint8, error) { | |
| return _UniswapV2ERC20.Contract.Decimals(&_UniswapV2ERC20.CallOpts) | |
| } | |
| // Decimals is a free data retrieval call binding the contract method 0x313ce567. | |
| // | |
| // Solidity: function decimals() view returns(uint8) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20CallerSession) Decimals() (uint8, error) { | |
| return _UniswapV2ERC20.Contract.Decimals(&_UniswapV2ERC20.CallOpts) | |
| } | |
| // Name is a free data retrieval call binding the contract method 0x06fdde03. | |
| // | |
| // Solidity: function name() view returns(string) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Caller) Name(opts *bind.CallOpts) (string, error) { | |
| var out []interface{} | |
| err := _UniswapV2ERC20.contract.Call(opts, &out, "name") | |
| if err != nil { | |
| return *new(string), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(string)).(*string) | |
| return out0, err | |
| } | |
| // Name is a free data retrieval call binding the contract method 0x06fdde03. | |
| // | |
| // Solidity: function name() view returns(string) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Session) Name() (string, error) { | |
| return _UniswapV2ERC20.Contract.Name(&_UniswapV2ERC20.CallOpts) | |
| } | |
| // Name is a free data retrieval call binding the contract method 0x06fdde03. | |
| // | |
| // Solidity: function name() view returns(string) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20CallerSession) Name() (string, error) { | |
| return _UniswapV2ERC20.Contract.Name(&_UniswapV2ERC20.CallOpts) | |
| } | |
| // Nonces is a free data retrieval call binding the contract method 0x7ecebe00. | |
| // | |
| // Solidity: function nonces(address ) view returns(uint256) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Caller) Nonces(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { | |
| var out []interface{} | |
| err := _UniswapV2ERC20.contract.Call(opts, &out, "nonces", arg0) | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // Nonces is a free data retrieval call binding the contract method 0x7ecebe00. | |
| // | |
| // Solidity: function nonces(address ) view returns(uint256) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Session) Nonces(arg0 common.Address) (*big.Int, error) { | |
| return _UniswapV2ERC20.Contract.Nonces(&_UniswapV2ERC20.CallOpts, arg0) | |
| } | |
| // Nonces is a free data retrieval call binding the contract method 0x7ecebe00. | |
| // | |
| // Solidity: function nonces(address ) view returns(uint256) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20CallerSession) Nonces(arg0 common.Address) (*big.Int, error) { | |
| return _UniswapV2ERC20.Contract.Nonces(&_UniswapV2ERC20.CallOpts, arg0) | |
| } | |
| // Symbol is a free data retrieval call binding the contract method 0x95d89b41. | |
| // | |
| // Solidity: function symbol() view returns(string) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Caller) Symbol(opts *bind.CallOpts) (string, error) { | |
| var out []interface{} | |
| err := _UniswapV2ERC20.contract.Call(opts, &out, "symbol") | |
| if err != nil { | |
| return *new(string), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(string)).(*string) | |
| return out0, err | |
| } | |
| // Symbol is a free data retrieval call binding the contract method 0x95d89b41. | |
| // | |
| // Solidity: function symbol() view returns(string) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Session) Symbol() (string, error) { | |
| return _UniswapV2ERC20.Contract.Symbol(&_UniswapV2ERC20.CallOpts) | |
| } | |
| // Symbol is a free data retrieval call binding the contract method 0x95d89b41. | |
| // | |
| // Solidity: function symbol() view returns(string) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20CallerSession) Symbol() (string, error) { | |
| return _UniswapV2ERC20.Contract.Symbol(&_UniswapV2ERC20.CallOpts) | |
| } | |
| // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. | |
| // | |
| // Solidity: function totalSupply() view returns(uint256) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { | |
| var out []interface{} | |
| err := _UniswapV2ERC20.contract.Call(opts, &out, "totalSupply") | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. | |
| // | |
| // Solidity: function totalSupply() view returns(uint256) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Session) TotalSupply() (*big.Int, error) { | |
| return _UniswapV2ERC20.Contract.TotalSupply(&_UniswapV2ERC20.CallOpts) | |
| } | |
| // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. | |
| // | |
| // Solidity: function totalSupply() view returns(uint256) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20CallerSession) TotalSupply() (*big.Int, error) { | |
| return _UniswapV2ERC20.Contract.TotalSupply(&_UniswapV2ERC20.CallOpts) | |
| } | |
| // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. | |
| // | |
| // Solidity: function approve(address spender, uint256 value) returns(bool) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _UniswapV2ERC20.contract.Transact(opts, "approve", spender, value) | |
| } | |
| // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. | |
| // | |
| // Solidity: function approve(address spender, uint256 value) returns(bool) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Session) Approve(spender common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _UniswapV2ERC20.Contract.Approve(&_UniswapV2ERC20.TransactOpts, spender, value) | |
| } | |
| // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. | |
| // | |
| // Solidity: function approve(address spender, uint256 value) returns(bool) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20TransactorSession) Approve(spender common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _UniswapV2ERC20.Contract.Approve(&_UniswapV2ERC20.TransactOpts, spender, value) | |
| } | |
| // Permit is a paid mutator transaction binding the contract method 0xd505accf. | |
| // | |
| // Solidity: function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) returns() | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Transactor) Permit(opts *bind.TransactOpts, owner common.Address, spender common.Address, value *big.Int, deadline *big.Int, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) { | |
| return _UniswapV2ERC20.contract.Transact(opts, "permit", owner, spender, value, deadline, v, r, s) | |
| } | |
| // Permit is a paid mutator transaction binding the contract method 0xd505accf. | |
| // | |
| // Solidity: function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) returns() | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Session) Permit(owner common.Address, spender common.Address, value *big.Int, deadline *big.Int, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) { | |
| return _UniswapV2ERC20.Contract.Permit(&_UniswapV2ERC20.TransactOpts, owner, spender, value, deadline, v, r, s) | |
| } | |
| // Permit is a paid mutator transaction binding the contract method 0xd505accf. | |
| // | |
| // Solidity: function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) returns() | |
| func (_UniswapV2ERC20 *UniswapV2ERC20TransactorSession) Permit(owner common.Address, spender common.Address, value *big.Int, deadline *big.Int, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) { | |
| return _UniswapV2ERC20.Contract.Permit(&_UniswapV2ERC20.TransactOpts, owner, spender, value, deadline, v, r, s) | |
| } | |
| // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. | |
| // | |
| // Solidity: function transfer(address to, uint256 value) returns(bool) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Transactor) Transfer(opts *bind.TransactOpts, to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _UniswapV2ERC20.contract.Transact(opts, "transfer", to, value) | |
| } | |
| // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. | |
| // | |
| // Solidity: function transfer(address to, uint256 value) returns(bool) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Session) Transfer(to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _UniswapV2ERC20.Contract.Transfer(&_UniswapV2ERC20.TransactOpts, to, value) | |
| } | |
| // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. | |
| // | |
| // Solidity: function transfer(address to, uint256 value) returns(bool) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20TransactorSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _UniswapV2ERC20.Contract.Transfer(&_UniswapV2ERC20.TransactOpts, to, value) | |
| } | |
| // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. | |
| // | |
| // Solidity: function transferFrom(address from, address to, uint256 value) returns(bool) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _UniswapV2ERC20.contract.Transact(opts, "transferFrom", from, to, value) | |
| } | |
| // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. | |
| // | |
| // Solidity: function transferFrom(address from, address to, uint256 value) returns(bool) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Session) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _UniswapV2ERC20.Contract.TransferFrom(&_UniswapV2ERC20.TransactOpts, from, to, value) | |
| } | |
| // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. | |
| // | |
| // Solidity: function transferFrom(address from, address to, uint256 value) returns(bool) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20TransactorSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _UniswapV2ERC20.Contract.TransferFrom(&_UniswapV2ERC20.TransactOpts, from, to, value) | |
| } | |
| // UniswapV2ERC20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the UniswapV2ERC20 contract. | |
| type UniswapV2ERC20ApprovalIterator struct { | |
| Event *UniswapV2ERC20Approval // 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 *UniswapV2ERC20ApprovalIterator) 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(UniswapV2ERC20Approval) | |
| 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(UniswapV2ERC20Approval) | |
| 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 *UniswapV2ERC20ApprovalIterator) Error() error { | |
| return it.fail | |
| } | |
| // Close terminates the iteration process, releasing any pending underlying | |
| // resources. | |
| func (it *UniswapV2ERC20ApprovalIterator) Close() error { | |
| it.sub.Unsubscribe() | |
| return nil | |
| } | |
| // UniswapV2ERC20Approval represents a Approval event raised by the UniswapV2ERC20 contract. | |
| type UniswapV2ERC20Approval struct { | |
| Owner common.Address | |
| Spender common.Address | |
| Value *big.Int | |
| Raw types.Log // Blockchain specific contextual infos | |
| } | |
| // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. | |
| // | |
| // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*UniswapV2ERC20ApprovalIterator, error) { | |
| var ownerRule []interface{} | |
| for _, ownerItem := range owner { | |
| ownerRule = append(ownerRule, ownerItem) | |
| } | |
| var spenderRule []interface{} | |
| for _, spenderItem := range spender { | |
| spenderRule = append(spenderRule, spenderItem) | |
| } | |
| logs, sub, err := _UniswapV2ERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &UniswapV2ERC20ApprovalIterator{contract: _UniswapV2ERC20.contract, event: "Approval", logs: logs, sub: sub}, nil | |
| } | |
| // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. | |
| // | |
| // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *UniswapV2ERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) { | |
| var ownerRule []interface{} | |
| for _, ownerItem := range owner { | |
| ownerRule = append(ownerRule, ownerItem) | |
| } | |
| var spenderRule []interface{} | |
| for _, spenderItem := range spender { | |
| spenderRule = append(spenderRule, spenderItem) | |
| } | |
| logs, sub, err := _UniswapV2ERC20.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) | |
| 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(UniswapV2ERC20Approval) | |
| if err := _UniswapV2ERC20.contract.UnpackLog(event, "Approval", 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 | |
| } | |
| // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. | |
| // | |
| // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Filterer) ParseApproval(log types.Log) (*UniswapV2ERC20Approval, error) { | |
| event := new(UniswapV2ERC20Approval) | |
| if err := _UniswapV2ERC20.contract.UnpackLog(event, "Approval", log); err != nil { | |
| return nil, err | |
| } | |
| return event, nil | |
| } | |
| // UniswapV2ERC20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the UniswapV2ERC20 contract. | |
| type UniswapV2ERC20TransferIterator struct { | |
| Event *UniswapV2ERC20Transfer // 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 *UniswapV2ERC20TransferIterator) 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(UniswapV2ERC20Transfer) | |
| 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(UniswapV2ERC20Transfer) | |
| 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 *UniswapV2ERC20TransferIterator) Error() error { | |
| return it.fail | |
| } | |
| // Close terminates the iteration process, releasing any pending underlying | |
| // resources. | |
| func (it *UniswapV2ERC20TransferIterator) Close() error { | |
| it.sub.Unsubscribe() | |
| return nil | |
| } | |
| // UniswapV2ERC20Transfer represents a Transfer event raised by the UniswapV2ERC20 contract. | |
| type UniswapV2ERC20Transfer struct { | |
| From common.Address | |
| To common.Address | |
| Value *big.Int | |
| Raw types.Log // Blockchain specific contextual infos | |
| } | |
| // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. | |
| // | |
| // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*UniswapV2ERC20TransferIterator, error) { | |
| var fromRule []interface{} | |
| for _, fromItem := range from { | |
| fromRule = append(fromRule, fromItem) | |
| } | |
| var toRule []interface{} | |
| for _, toItem := range to { | |
| toRule = append(toRule, toItem) | |
| } | |
| logs, sub, err := _UniswapV2ERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &UniswapV2ERC20TransferIterator{contract: _UniswapV2ERC20.contract, event: "Transfer", logs: logs, sub: sub}, nil | |
| } | |
| // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. | |
| // | |
| // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *UniswapV2ERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) { | |
| var fromRule []interface{} | |
| for _, fromItem := range from { | |
| fromRule = append(fromRule, fromItem) | |
| } | |
| var toRule []interface{} | |
| for _, toItem := range to { | |
| toRule = append(toRule, toItem) | |
| } | |
| logs, sub, err := _UniswapV2ERC20.contract.WatchLogs(opts, "Transfer", fromRule, toRule) | |
| 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(UniswapV2ERC20Transfer) | |
| if err := _UniswapV2ERC20.contract.UnpackLog(event, "Transfer", 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 | |
| } | |
| // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. | |
| // | |
| // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) | |
| func (_UniswapV2ERC20 *UniswapV2ERC20Filterer) ParseTransfer(log types.Log) (*UniswapV2ERC20Transfer, error) { | |
| event := new(UniswapV2ERC20Transfer) | |
| if err := _UniswapV2ERC20.contract.UnpackLog(event, "Transfer", log); err != nil { | |
| return nil, err | |
| } | |
| return event, nil | |
| } | |
| // UniswapV2PairABI is the input ABI used to generate the binding from. | |
| const UniswapV2PairABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"Burn\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"}],\"name\":\"Mint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount0In\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount1In\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount0Out\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount1Out\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"Swap\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint112\",\"name\":\"reserve0\",\"type\":\"uint112\"},{\"indexed\":false,\"internalType\":\"uint112\",\"name\":\"reserve1\",\"type\":\"uint112\"}],\"name\":\"Sync\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[],\"name\":\"DOMAIN_SEPARATOR\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"MINIMUM_LIQUIDITY\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"PERMIT_TYPEHASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"burn\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amount0\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount1\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"factory\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"getReserves\",\"outputs\":[{\"internalType\":\"uint112\",\"name\":\"_reserve0\",\"type\":\"uint112\"},{\"internalType\":\"uint112\",\"name\":\"_reserve1\",\"type\":\"uint112\"},{\"internalType\":\"uint32\",\"name\":\"_blockTimestampLast\",\"type\":\"uint32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_token0\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_token1\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"kLast\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"mint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"liquidity\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"nonces\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"permit\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"price0CumulativeLast\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"price1CumulativeLast\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"skim\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount0Out\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount1Out\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"swap\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"sync\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"token0\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"token1\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" | |
| // UniswapV2PairFuncSigs maps the 4-byte function signature to its string representation. | |
| var UniswapV2PairFuncSigs = map[string]string{ | |
| "3644e515": "DOMAIN_SEPARATOR()", | |
| "ba9a7a56": "MINIMUM_LIQUIDITY()", | |
| "30adf81f": "PERMIT_TYPEHASH()", | |
| "dd62ed3e": "allowance(address,address)", | |
| "095ea7b3": "approve(address,uint256)", | |
| "70a08231": "balanceOf(address)", | |
| "89afcb44": "burn(address)", | |
| "313ce567": "decimals()", | |
| "c45a0155": "factory()", | |
| "0902f1ac": "getReserves()", | |
| "485cc955": "initialize(address,address)", | |
| "7464fc3d": "kLast()", | |
| "6a627842": "mint(address)", | |
| "06fdde03": "name()", | |
| "7ecebe00": "nonces(address)", | |
| "d505accf": "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)", | |
| "5909c0d5": "price0CumulativeLast()", | |
| "5a3d5493": "price1CumulativeLast()", | |
| "bc25cf77": "skim(address)", | |
| "022c0d9f": "swap(uint256,uint256,address,bytes)", | |
| "95d89b41": "symbol()", | |
| "fff6cae9": "sync()", | |
| "0dfe1681": "token0()", | |
| "d21220a7": "token1()", | |
| "18160ddd": "totalSupply()", | |
| "a9059cbb": "transfer(address,uint256)", | |
| "23b872dd": "transferFrom(address,address,uint256)", | |
| } | |
| // UniswapV2PairBin is the compiled bytecode used for deploying new contracts. | |
| var UniswapV2PairBin = "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" | |
| // DeployUniswapV2Pair deploys a new Ethereum contract, binding an instance of UniswapV2Pair to it. | |
| func DeployUniswapV2Pair(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *UniswapV2Pair, error) { | |
| parsed, err := abi.JSON(strings.NewReader(UniswapV2PairABI)) | |
| if err != nil { | |
| return common.Address{}, nil, nil, err | |
| } | |
| address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(UniswapV2PairBin), backend) | |
| if err != nil { | |
| return common.Address{}, nil, nil, err | |
| } | |
| return address, tx, &UniswapV2Pair{UniswapV2PairCaller: UniswapV2PairCaller{contract: contract}, UniswapV2PairTransactor: UniswapV2PairTransactor{contract: contract}, UniswapV2PairFilterer: UniswapV2PairFilterer{contract: contract}}, nil | |
| } | |
| // UniswapV2Pair is an auto generated Go binding around an Ethereum contract. | |
| type UniswapV2Pair struct { | |
| UniswapV2PairCaller // Read-only binding to the contract | |
| UniswapV2PairTransactor // Write-only binding to the contract | |
| UniswapV2PairFilterer // Log filterer for contract events | |
| } | |
| // UniswapV2PairCaller is an auto generated read-only Go binding around an Ethereum contract. | |
| type UniswapV2PairCaller struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // UniswapV2PairTransactor is an auto generated write-only Go binding around an Ethereum contract. | |
| type UniswapV2PairTransactor struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // UniswapV2PairFilterer is an auto generated log filtering Go binding around an Ethereum contract events. | |
| type UniswapV2PairFilterer struct { | |
| contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
| } | |
| // UniswapV2PairSession is an auto generated Go binding around an Ethereum contract, | |
| // with pre-set call and transact options. | |
| type UniswapV2PairSession struct { | |
| Contract *UniswapV2Pair // 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 | |
| } | |
| // UniswapV2PairCallerSession is an auto generated read-only Go binding around an Ethereum contract, | |
| // with pre-set call options. | |
| type UniswapV2PairCallerSession struct { | |
| Contract *UniswapV2PairCaller // Generic contract caller binding to set the session for | |
| CallOpts bind.CallOpts // Call options to use throughout this session | |
| } | |
| // UniswapV2PairTransactorSession is an auto generated write-only Go binding around an Ethereum contract, | |
| // with pre-set transact options. | |
| type UniswapV2PairTransactorSession struct { | |
| Contract *UniswapV2PairTransactor // Generic contract transactor binding to set the session for | |
| TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session | |
| } | |
| // UniswapV2PairRaw is an auto generated low-level Go binding around an Ethereum contract. | |
| type UniswapV2PairRaw struct { | |
| Contract *UniswapV2Pair // Generic contract binding to access the raw methods on | |
| } | |
| // UniswapV2PairCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. | |
| type UniswapV2PairCallerRaw struct { | |
| Contract *UniswapV2PairCaller // Generic read-only contract binding to access the raw methods on | |
| } | |
| // UniswapV2PairTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. | |
| type UniswapV2PairTransactorRaw struct { | |
| Contract *UniswapV2PairTransactor // Generic write-only contract binding to access the raw methods on | |
| } | |
| // NewUniswapV2Pair creates a new instance of UniswapV2Pair, bound to a specific deployed contract. | |
| func NewUniswapV2Pair(address common.Address, backend bind.ContractBackend) (*UniswapV2Pair, error) { | |
| contract, err := bindUniswapV2Pair(address, backend, backend, backend) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &UniswapV2Pair{UniswapV2PairCaller: UniswapV2PairCaller{contract: contract}, UniswapV2PairTransactor: UniswapV2PairTransactor{contract: contract}, UniswapV2PairFilterer: UniswapV2PairFilterer{contract: contract}}, nil | |
| } | |
| // NewUniswapV2PairCaller creates a new read-only instance of UniswapV2Pair, bound to a specific deployed contract. | |
| func NewUniswapV2PairCaller(address common.Address, caller bind.ContractCaller) (*UniswapV2PairCaller, error) { | |
| contract, err := bindUniswapV2Pair(address, caller, nil, nil) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &UniswapV2PairCaller{contract: contract}, nil | |
| } | |
| // NewUniswapV2PairTransactor creates a new write-only instance of UniswapV2Pair, bound to a specific deployed contract. | |
| func NewUniswapV2PairTransactor(address common.Address, transactor bind.ContractTransactor) (*UniswapV2PairTransactor, error) { | |
| contract, err := bindUniswapV2Pair(address, nil, transactor, nil) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &UniswapV2PairTransactor{contract: contract}, nil | |
| } | |
| // NewUniswapV2PairFilterer creates a new log filterer instance of UniswapV2Pair, bound to a specific deployed contract. | |
| func NewUniswapV2PairFilterer(address common.Address, filterer bind.ContractFilterer) (*UniswapV2PairFilterer, error) { | |
| contract, err := bindUniswapV2Pair(address, nil, nil, filterer) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &UniswapV2PairFilterer{contract: contract}, nil | |
| } | |
| // bindUniswapV2Pair binds a generic wrapper to an already deployed contract. | |
| func bindUniswapV2Pair(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { | |
| parsed, err := abi.JSON(strings.NewReader(UniswapV2PairABI)) | |
| 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 (_UniswapV2Pair *UniswapV2PairRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { | |
| return _UniswapV2Pair.Contract.UniswapV2PairCaller.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 (_UniswapV2Pair *UniswapV2PairRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.UniswapV2PairTransactor.contract.Transfer(opts) | |
| } | |
| // Transact invokes the (paid) contract method with params as input values. | |
| func (_UniswapV2Pair *UniswapV2PairRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.UniswapV2PairTransactor.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 (_UniswapV2Pair *UniswapV2PairCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { | |
| return _UniswapV2Pair.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 (_UniswapV2Pair *UniswapV2PairTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.contract.Transfer(opts) | |
| } | |
| // Transact invokes the (paid) contract method with params as input values. | |
| func (_UniswapV2Pair *UniswapV2PairTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.contract.Transact(opts, method, params...) | |
| } | |
| // DOMAINSEPARATOR is a free data retrieval call binding the contract method 0x3644e515. | |
| // | |
| // Solidity: function DOMAIN_SEPARATOR() view returns(bytes32) | |
| func (_UniswapV2Pair *UniswapV2PairCaller) DOMAINSEPARATOR(opts *bind.CallOpts) ([32]byte, error) { | |
| var out []interface{} | |
| err := _UniswapV2Pair.contract.Call(opts, &out, "DOMAIN_SEPARATOR") | |
| if err != nil { | |
| return *new([32]byte), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) | |
| return out0, err | |
| } | |
| // DOMAINSEPARATOR is a free data retrieval call binding the contract method 0x3644e515. | |
| // | |
| // Solidity: function DOMAIN_SEPARATOR() view returns(bytes32) | |
| func (_UniswapV2Pair *UniswapV2PairSession) DOMAINSEPARATOR() ([32]byte, error) { | |
| return _UniswapV2Pair.Contract.DOMAINSEPARATOR(&_UniswapV2Pair.CallOpts) | |
| } | |
| // DOMAINSEPARATOR is a free data retrieval call binding the contract method 0x3644e515. | |
| // | |
| // Solidity: function DOMAIN_SEPARATOR() view returns(bytes32) | |
| func (_UniswapV2Pair *UniswapV2PairCallerSession) DOMAINSEPARATOR() ([32]byte, error) { | |
| return _UniswapV2Pair.Contract.DOMAINSEPARATOR(&_UniswapV2Pair.CallOpts) | |
| } | |
| // MINIMUMLIQUIDITY is a free data retrieval call binding the contract method 0xba9a7a56. | |
| // | |
| // Solidity: function MINIMUM_LIQUIDITY() view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairCaller) MINIMUMLIQUIDITY(opts *bind.CallOpts) (*big.Int, error) { | |
| var out []interface{} | |
| err := _UniswapV2Pair.contract.Call(opts, &out, "MINIMUM_LIQUIDITY") | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // MINIMUMLIQUIDITY is a free data retrieval call binding the contract method 0xba9a7a56. | |
| // | |
| // Solidity: function MINIMUM_LIQUIDITY() view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairSession) MINIMUMLIQUIDITY() (*big.Int, error) { | |
| return _UniswapV2Pair.Contract.MINIMUMLIQUIDITY(&_UniswapV2Pair.CallOpts) | |
| } | |
| // MINIMUMLIQUIDITY is a free data retrieval call binding the contract method 0xba9a7a56. | |
| // | |
| // Solidity: function MINIMUM_LIQUIDITY() view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairCallerSession) MINIMUMLIQUIDITY() (*big.Int, error) { | |
| return _UniswapV2Pair.Contract.MINIMUMLIQUIDITY(&_UniswapV2Pair.CallOpts) | |
| } | |
| // PERMITTYPEHASH is a free data retrieval call binding the contract method 0x30adf81f. | |
| // | |
| // Solidity: function PERMIT_TYPEHASH() view returns(bytes32) | |
| func (_UniswapV2Pair *UniswapV2PairCaller) PERMITTYPEHASH(opts *bind.CallOpts) ([32]byte, error) { | |
| var out []interface{} | |
| err := _UniswapV2Pair.contract.Call(opts, &out, "PERMIT_TYPEHASH") | |
| if err != nil { | |
| return *new([32]byte), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) | |
| return out0, err | |
| } | |
| // PERMITTYPEHASH is a free data retrieval call binding the contract method 0x30adf81f. | |
| // | |
| // Solidity: function PERMIT_TYPEHASH() view returns(bytes32) | |
| func (_UniswapV2Pair *UniswapV2PairSession) PERMITTYPEHASH() ([32]byte, error) { | |
| return _UniswapV2Pair.Contract.PERMITTYPEHASH(&_UniswapV2Pair.CallOpts) | |
| } | |
| // PERMITTYPEHASH is a free data retrieval call binding the contract method 0x30adf81f. | |
| // | |
| // Solidity: function PERMIT_TYPEHASH() view returns(bytes32) | |
| func (_UniswapV2Pair *UniswapV2PairCallerSession) PERMITTYPEHASH() ([32]byte, error) { | |
| return _UniswapV2Pair.Contract.PERMITTYPEHASH(&_UniswapV2Pair.CallOpts) | |
| } | |
| // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. | |
| // | |
| // Solidity: function allowance(address , address ) view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairCaller) Allowance(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (*big.Int, error) { | |
| var out []interface{} | |
| err := _UniswapV2Pair.contract.Call(opts, &out, "allowance", arg0, arg1) | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. | |
| // | |
| // Solidity: function allowance(address , address ) view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairSession) Allowance(arg0 common.Address, arg1 common.Address) (*big.Int, error) { | |
| return _UniswapV2Pair.Contract.Allowance(&_UniswapV2Pair.CallOpts, arg0, arg1) | |
| } | |
| // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. | |
| // | |
| // Solidity: function allowance(address , address ) view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairCallerSession) Allowance(arg0 common.Address, arg1 common.Address) (*big.Int, error) { | |
| return _UniswapV2Pair.Contract.Allowance(&_UniswapV2Pair.CallOpts, arg0, arg1) | |
| } | |
| // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. | |
| // | |
| // Solidity: function balanceOf(address ) view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairCaller) BalanceOf(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { | |
| var out []interface{} | |
| err := _UniswapV2Pair.contract.Call(opts, &out, "balanceOf", arg0) | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. | |
| // | |
| // Solidity: function balanceOf(address ) view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairSession) BalanceOf(arg0 common.Address) (*big.Int, error) { | |
| return _UniswapV2Pair.Contract.BalanceOf(&_UniswapV2Pair.CallOpts, arg0) | |
| } | |
| // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. | |
| // | |
| // Solidity: function balanceOf(address ) view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairCallerSession) BalanceOf(arg0 common.Address) (*big.Int, error) { | |
| return _UniswapV2Pair.Contract.BalanceOf(&_UniswapV2Pair.CallOpts, arg0) | |
| } | |
| // Decimals is a free data retrieval call binding the contract method 0x313ce567. | |
| // | |
| // Solidity: function decimals() view returns(uint8) | |
| func (_UniswapV2Pair *UniswapV2PairCaller) Decimals(opts *bind.CallOpts) (uint8, error) { | |
| var out []interface{} | |
| err := _UniswapV2Pair.contract.Call(opts, &out, "decimals") | |
| if err != nil { | |
| return *new(uint8), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) | |
| return out0, err | |
| } | |
| // Decimals is a free data retrieval call binding the contract method 0x313ce567. | |
| // | |
| // Solidity: function decimals() view returns(uint8) | |
| func (_UniswapV2Pair *UniswapV2PairSession) Decimals() (uint8, error) { | |
| return _UniswapV2Pair.Contract.Decimals(&_UniswapV2Pair.CallOpts) | |
| } | |
| // Decimals is a free data retrieval call binding the contract method 0x313ce567. | |
| // | |
| // Solidity: function decimals() view returns(uint8) | |
| func (_UniswapV2Pair *UniswapV2PairCallerSession) Decimals() (uint8, error) { | |
| return _UniswapV2Pair.Contract.Decimals(&_UniswapV2Pair.CallOpts) | |
| } | |
| // Factory is a free data retrieval call binding the contract method 0xc45a0155. | |
| // | |
| // Solidity: function factory() view returns(address) | |
| func (_UniswapV2Pair *UniswapV2PairCaller) Factory(opts *bind.CallOpts) (common.Address, error) { | |
| var out []interface{} | |
| err := _UniswapV2Pair.contract.Call(opts, &out, "factory") | |
| if err != nil { | |
| return *new(common.Address), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) | |
| return out0, err | |
| } | |
| // Factory is a free data retrieval call binding the contract method 0xc45a0155. | |
| // | |
| // Solidity: function factory() view returns(address) | |
| func (_UniswapV2Pair *UniswapV2PairSession) Factory() (common.Address, error) { | |
| return _UniswapV2Pair.Contract.Factory(&_UniswapV2Pair.CallOpts) | |
| } | |
| // Factory is a free data retrieval call binding the contract method 0xc45a0155. | |
| // | |
| // Solidity: function factory() view returns(address) | |
| func (_UniswapV2Pair *UniswapV2PairCallerSession) Factory() (common.Address, error) { | |
| return _UniswapV2Pair.Contract.Factory(&_UniswapV2Pair.CallOpts) | |
| } | |
| // GetReserves is a free data retrieval call binding the contract method 0x0902f1ac. | |
| // | |
| // Solidity: function getReserves() view returns(uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) | |
| func (_UniswapV2Pair *UniswapV2PairCaller) GetReserves(opts *bind.CallOpts) (struct { | |
| Reserve0 *big.Int | |
| Reserve1 *big.Int | |
| BlockTimestampLast uint32 | |
| }, error) { | |
| var out []interface{} | |
| err := _UniswapV2Pair.contract.Call(opts, &out, "getReserves") | |
| outstruct := new(struct { | |
| Reserve0 *big.Int | |
| Reserve1 *big.Int | |
| BlockTimestampLast uint32 | |
| }) | |
| outstruct.Reserve0 = out[0].(*big.Int) | |
| outstruct.Reserve1 = out[1].(*big.Int) | |
| outstruct.BlockTimestampLast = out[2].(uint32) | |
| return *outstruct, err | |
| } | |
| // GetReserves is a free data retrieval call binding the contract method 0x0902f1ac. | |
| // | |
| // Solidity: function getReserves() view returns(uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) | |
| func (_UniswapV2Pair *UniswapV2PairSession) GetReserves() (struct { | |
| Reserve0 *big.Int | |
| Reserve1 *big.Int | |
| BlockTimestampLast uint32 | |
| }, error) { | |
| return _UniswapV2Pair.Contract.GetReserves(&_UniswapV2Pair.CallOpts) | |
| } | |
| // GetReserves is a free data retrieval call binding the contract method 0x0902f1ac. | |
| // | |
| // Solidity: function getReserves() view returns(uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) | |
| func (_UniswapV2Pair *UniswapV2PairCallerSession) GetReserves() (struct { | |
| Reserve0 *big.Int | |
| Reserve1 *big.Int | |
| BlockTimestampLast uint32 | |
| }, error) { | |
| return _UniswapV2Pair.Contract.GetReserves(&_UniswapV2Pair.CallOpts) | |
| } | |
| // KLast is a free data retrieval call binding the contract method 0x7464fc3d. | |
| // | |
| // Solidity: function kLast() view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairCaller) KLast(opts *bind.CallOpts) (*big.Int, error) { | |
| var out []interface{} | |
| err := _UniswapV2Pair.contract.Call(opts, &out, "kLast") | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // KLast is a free data retrieval call binding the contract method 0x7464fc3d. | |
| // | |
| // Solidity: function kLast() view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairSession) KLast() (*big.Int, error) { | |
| return _UniswapV2Pair.Contract.KLast(&_UniswapV2Pair.CallOpts) | |
| } | |
| // KLast is a free data retrieval call binding the contract method 0x7464fc3d. | |
| // | |
| // Solidity: function kLast() view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairCallerSession) KLast() (*big.Int, error) { | |
| return _UniswapV2Pair.Contract.KLast(&_UniswapV2Pair.CallOpts) | |
| } | |
| // Name is a free data retrieval call binding the contract method 0x06fdde03. | |
| // | |
| // Solidity: function name() view returns(string) | |
| func (_UniswapV2Pair *UniswapV2PairCaller) Name(opts *bind.CallOpts) (string, error) { | |
| var out []interface{} | |
| err := _UniswapV2Pair.contract.Call(opts, &out, "name") | |
| if err != nil { | |
| return *new(string), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(string)).(*string) | |
| return out0, err | |
| } | |
| // Name is a free data retrieval call binding the contract method 0x06fdde03. | |
| // | |
| // Solidity: function name() view returns(string) | |
| func (_UniswapV2Pair *UniswapV2PairSession) Name() (string, error) { | |
| return _UniswapV2Pair.Contract.Name(&_UniswapV2Pair.CallOpts) | |
| } | |
| // Name is a free data retrieval call binding the contract method 0x06fdde03. | |
| // | |
| // Solidity: function name() view returns(string) | |
| func (_UniswapV2Pair *UniswapV2PairCallerSession) Name() (string, error) { | |
| return _UniswapV2Pair.Contract.Name(&_UniswapV2Pair.CallOpts) | |
| } | |
| // Nonces is a free data retrieval call binding the contract method 0x7ecebe00. | |
| // | |
| // Solidity: function nonces(address ) view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairCaller) Nonces(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { | |
| var out []interface{} | |
| err := _UniswapV2Pair.contract.Call(opts, &out, "nonces", arg0) | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // Nonces is a free data retrieval call binding the contract method 0x7ecebe00. | |
| // | |
| // Solidity: function nonces(address ) view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairSession) Nonces(arg0 common.Address) (*big.Int, error) { | |
| return _UniswapV2Pair.Contract.Nonces(&_UniswapV2Pair.CallOpts, arg0) | |
| } | |
| // Nonces is a free data retrieval call binding the contract method 0x7ecebe00. | |
| // | |
| // Solidity: function nonces(address ) view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairCallerSession) Nonces(arg0 common.Address) (*big.Int, error) { | |
| return _UniswapV2Pair.Contract.Nonces(&_UniswapV2Pair.CallOpts, arg0) | |
| } | |
| // Price0CumulativeLast is a free data retrieval call binding the contract method 0x5909c0d5. | |
| // | |
| // Solidity: function price0CumulativeLast() view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairCaller) Price0CumulativeLast(opts *bind.CallOpts) (*big.Int, error) { | |
| var out []interface{} | |
| err := _UniswapV2Pair.contract.Call(opts, &out, "price0CumulativeLast") | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // Price0CumulativeLast is a free data retrieval call binding the contract method 0x5909c0d5. | |
| // | |
| // Solidity: function price0CumulativeLast() view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairSession) Price0CumulativeLast() (*big.Int, error) { | |
| return _UniswapV2Pair.Contract.Price0CumulativeLast(&_UniswapV2Pair.CallOpts) | |
| } | |
| // Price0CumulativeLast is a free data retrieval call binding the contract method 0x5909c0d5. | |
| // | |
| // Solidity: function price0CumulativeLast() view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairCallerSession) Price0CumulativeLast() (*big.Int, error) { | |
| return _UniswapV2Pair.Contract.Price0CumulativeLast(&_UniswapV2Pair.CallOpts) | |
| } | |
| // Price1CumulativeLast is a free data retrieval call binding the contract method 0x5a3d5493. | |
| // | |
| // Solidity: function price1CumulativeLast() view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairCaller) Price1CumulativeLast(opts *bind.CallOpts) (*big.Int, error) { | |
| var out []interface{} | |
| err := _UniswapV2Pair.contract.Call(opts, &out, "price1CumulativeLast") | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // Price1CumulativeLast is a free data retrieval call binding the contract method 0x5a3d5493. | |
| // | |
| // Solidity: function price1CumulativeLast() view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairSession) Price1CumulativeLast() (*big.Int, error) { | |
| return _UniswapV2Pair.Contract.Price1CumulativeLast(&_UniswapV2Pair.CallOpts) | |
| } | |
| // Price1CumulativeLast is a free data retrieval call binding the contract method 0x5a3d5493. | |
| // | |
| // Solidity: function price1CumulativeLast() view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairCallerSession) Price1CumulativeLast() (*big.Int, error) { | |
| return _UniswapV2Pair.Contract.Price1CumulativeLast(&_UniswapV2Pair.CallOpts) | |
| } | |
| // Symbol is a free data retrieval call binding the contract method 0x95d89b41. | |
| // | |
| // Solidity: function symbol() view returns(string) | |
| func (_UniswapV2Pair *UniswapV2PairCaller) Symbol(opts *bind.CallOpts) (string, error) { | |
| var out []interface{} | |
| err := _UniswapV2Pair.contract.Call(opts, &out, "symbol") | |
| if err != nil { | |
| return *new(string), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(string)).(*string) | |
| return out0, err | |
| } | |
| // Symbol is a free data retrieval call binding the contract method 0x95d89b41. | |
| // | |
| // Solidity: function symbol() view returns(string) | |
| func (_UniswapV2Pair *UniswapV2PairSession) Symbol() (string, error) { | |
| return _UniswapV2Pair.Contract.Symbol(&_UniswapV2Pair.CallOpts) | |
| } | |
| // Symbol is a free data retrieval call binding the contract method 0x95d89b41. | |
| // | |
| // Solidity: function symbol() view returns(string) | |
| func (_UniswapV2Pair *UniswapV2PairCallerSession) Symbol() (string, error) { | |
| return _UniswapV2Pair.Contract.Symbol(&_UniswapV2Pair.CallOpts) | |
| } | |
| // Token0 is a free data retrieval call binding the contract method 0x0dfe1681. | |
| // | |
| // Solidity: function token0() view returns(address) | |
| func (_UniswapV2Pair *UniswapV2PairCaller) Token0(opts *bind.CallOpts) (common.Address, error) { | |
| var out []interface{} | |
| err := _UniswapV2Pair.contract.Call(opts, &out, "token0") | |
| if err != nil { | |
| return *new(common.Address), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) | |
| return out0, err | |
| } | |
| // Token0 is a free data retrieval call binding the contract method 0x0dfe1681. | |
| // | |
| // Solidity: function token0() view returns(address) | |
| func (_UniswapV2Pair *UniswapV2PairSession) Token0() (common.Address, error) { | |
| return _UniswapV2Pair.Contract.Token0(&_UniswapV2Pair.CallOpts) | |
| } | |
| // Token0 is a free data retrieval call binding the contract method 0x0dfe1681. | |
| // | |
| // Solidity: function token0() view returns(address) | |
| func (_UniswapV2Pair *UniswapV2PairCallerSession) Token0() (common.Address, error) { | |
| return _UniswapV2Pair.Contract.Token0(&_UniswapV2Pair.CallOpts) | |
| } | |
| // Token1 is a free data retrieval call binding the contract method 0xd21220a7. | |
| // | |
| // Solidity: function token1() view returns(address) | |
| func (_UniswapV2Pair *UniswapV2PairCaller) Token1(opts *bind.CallOpts) (common.Address, error) { | |
| var out []interface{} | |
| err := _UniswapV2Pair.contract.Call(opts, &out, "token1") | |
| if err != nil { | |
| return *new(common.Address), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) | |
| return out0, err | |
| } | |
| // Token1 is a free data retrieval call binding the contract method 0xd21220a7. | |
| // | |
| // Solidity: function token1() view returns(address) | |
| func (_UniswapV2Pair *UniswapV2PairSession) Token1() (common.Address, error) { | |
| return _UniswapV2Pair.Contract.Token1(&_UniswapV2Pair.CallOpts) | |
| } | |
| // Token1 is a free data retrieval call binding the contract method 0xd21220a7. | |
| // | |
| // Solidity: function token1() view returns(address) | |
| func (_UniswapV2Pair *UniswapV2PairCallerSession) Token1() (common.Address, error) { | |
| return _UniswapV2Pair.Contract.Token1(&_UniswapV2Pair.CallOpts) | |
| } | |
| // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. | |
| // | |
| // Solidity: function totalSupply() view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { | |
| var out []interface{} | |
| err := _UniswapV2Pair.contract.Call(opts, &out, "totalSupply") | |
| if err != nil { | |
| return *new(*big.Int), err | |
| } | |
| out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
| return out0, err | |
| } | |
| // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. | |
| // | |
| // Solidity: function totalSupply() view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairSession) TotalSupply() (*big.Int, error) { | |
| return _UniswapV2Pair.Contract.TotalSupply(&_UniswapV2Pair.CallOpts) | |
| } | |
| // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. | |
| // | |
| // Solidity: function totalSupply() view returns(uint256) | |
| func (_UniswapV2Pair *UniswapV2PairCallerSession) TotalSupply() (*big.Int, error) { | |
| return _UniswapV2Pair.Contract.TotalSupply(&_UniswapV2Pair.CallOpts) | |
| } | |
| // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. | |
| // | |
| // Solidity: function approve(address spender, uint256 value) returns(bool) | |
| func (_UniswapV2Pair *UniswapV2PairTransactor) Approve(opts *bind.TransactOpts, spender common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _UniswapV2Pair.contract.Transact(opts, "approve", spender, value) | |
| } | |
| // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. | |
| // | |
| // Solidity: function approve(address spender, uint256 value) returns(bool) | |
| func (_UniswapV2Pair *UniswapV2PairSession) Approve(spender common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.Approve(&_UniswapV2Pair.TransactOpts, spender, value) | |
| } | |
| // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. | |
| // | |
| // Solidity: function approve(address spender, uint256 value) returns(bool) | |
| func (_UniswapV2Pair *UniswapV2PairTransactorSession) Approve(spender common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.Approve(&_UniswapV2Pair.TransactOpts, spender, value) | |
| } | |
| // Burn is a paid mutator transaction binding the contract method 0x89afcb44. | |
| // | |
| // Solidity: function burn(address to) returns(uint256 amount0, uint256 amount1) | |
| func (_UniswapV2Pair *UniswapV2PairTransactor) Burn(opts *bind.TransactOpts, to common.Address) (*types.Transaction, error) { | |
| return _UniswapV2Pair.contract.Transact(opts, "burn", to) | |
| } | |
| // Burn is a paid mutator transaction binding the contract method 0x89afcb44. | |
| // | |
| // Solidity: function burn(address to) returns(uint256 amount0, uint256 amount1) | |
| func (_UniswapV2Pair *UniswapV2PairSession) Burn(to common.Address) (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.Burn(&_UniswapV2Pair.TransactOpts, to) | |
| } | |
| // Burn is a paid mutator transaction binding the contract method 0x89afcb44. | |
| // | |
| // Solidity: function burn(address to) returns(uint256 amount0, uint256 amount1) | |
| func (_UniswapV2Pair *UniswapV2PairTransactorSession) Burn(to common.Address) (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.Burn(&_UniswapV2Pair.TransactOpts, to) | |
| } | |
| // Initialize is a paid mutator transaction binding the contract method 0x485cc955. | |
| // | |
| // Solidity: function initialize(address _token0, address _token1) returns() | |
| func (_UniswapV2Pair *UniswapV2PairTransactor) Initialize(opts *bind.TransactOpts, _token0 common.Address, _token1 common.Address) (*types.Transaction, error) { | |
| return _UniswapV2Pair.contract.Transact(opts, "initialize", _token0, _token1) | |
| } | |
| // Initialize is a paid mutator transaction binding the contract method 0x485cc955. | |
| // | |
| // Solidity: function initialize(address _token0, address _token1) returns() | |
| func (_UniswapV2Pair *UniswapV2PairSession) Initialize(_token0 common.Address, _token1 common.Address) (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.Initialize(&_UniswapV2Pair.TransactOpts, _token0, _token1) | |
| } | |
| // Initialize is a paid mutator transaction binding the contract method 0x485cc955. | |
| // | |
| // Solidity: function initialize(address _token0, address _token1) returns() | |
| func (_UniswapV2Pair *UniswapV2PairTransactorSession) Initialize(_token0 common.Address, _token1 common.Address) (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.Initialize(&_UniswapV2Pair.TransactOpts, _token0, _token1) | |
| } | |
| // Mint is a paid mutator transaction binding the contract method 0x6a627842. | |
| // | |
| // Solidity: function mint(address to) returns(uint256 liquidity) | |
| func (_UniswapV2Pair *UniswapV2PairTransactor) Mint(opts *bind.TransactOpts, to common.Address) (*types.Transaction, error) { | |
| return _UniswapV2Pair.contract.Transact(opts, "mint", to) | |
| } | |
| // Mint is a paid mutator transaction binding the contract method 0x6a627842. | |
| // | |
| // Solidity: function mint(address to) returns(uint256 liquidity) | |
| func (_UniswapV2Pair *UniswapV2PairSession) Mint(to common.Address) (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.Mint(&_UniswapV2Pair.TransactOpts, to) | |
| } | |
| // Mint is a paid mutator transaction binding the contract method 0x6a627842. | |
| // | |
| // Solidity: function mint(address to) returns(uint256 liquidity) | |
| func (_UniswapV2Pair *UniswapV2PairTransactorSession) Mint(to common.Address) (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.Mint(&_UniswapV2Pair.TransactOpts, to) | |
| } | |
| // Permit is a paid mutator transaction binding the contract method 0xd505accf. | |
| // | |
| // Solidity: function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) returns() | |
| func (_UniswapV2Pair *UniswapV2PairTransactor) Permit(opts *bind.TransactOpts, owner common.Address, spender common.Address, value *big.Int, deadline *big.Int, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) { | |
| return _UniswapV2Pair.contract.Transact(opts, "permit", owner, spender, value, deadline, v, r, s) | |
| } | |
| // Permit is a paid mutator transaction binding the contract method 0xd505accf. | |
| // | |
| // Solidity: function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) returns() | |
| func (_UniswapV2Pair *UniswapV2PairSession) Permit(owner common.Address, spender common.Address, value *big.Int, deadline *big.Int, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.Permit(&_UniswapV2Pair.TransactOpts, owner, spender, value, deadline, v, r, s) | |
| } | |
| // Permit is a paid mutator transaction binding the contract method 0xd505accf. | |
| // | |
| // Solidity: function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) returns() | |
| func (_UniswapV2Pair *UniswapV2PairTransactorSession) Permit(owner common.Address, spender common.Address, value *big.Int, deadline *big.Int, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.Permit(&_UniswapV2Pair.TransactOpts, owner, spender, value, deadline, v, r, s) | |
| } | |
| // Skim is a paid mutator transaction binding the contract method 0xbc25cf77. | |
| // | |
| // Solidity: function skim(address to) returns() | |
| func (_UniswapV2Pair *UniswapV2PairTransactor) Skim(opts *bind.TransactOpts, to common.Address) (*types.Transaction, error) { | |
| return _UniswapV2Pair.contract.Transact(opts, "skim", to) | |
| } | |
| // Skim is a paid mutator transaction binding the contract method 0xbc25cf77. | |
| // | |
| // Solidity: function skim(address to) returns() | |
| func (_UniswapV2Pair *UniswapV2PairSession) Skim(to common.Address) (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.Skim(&_UniswapV2Pair.TransactOpts, to) | |
| } | |
| // Skim is a paid mutator transaction binding the contract method 0xbc25cf77. | |
| // | |
| // Solidity: function skim(address to) returns() | |
| func (_UniswapV2Pair *UniswapV2PairTransactorSession) Skim(to common.Address) (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.Skim(&_UniswapV2Pair.TransactOpts, to) | |
| } | |
| // Swap is a paid mutator transaction binding the contract method 0x022c0d9f. | |
| // | |
| // Solidity: function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes data) returns() | |
| func (_UniswapV2Pair *UniswapV2PairTransactor) Swap(opts *bind.TransactOpts, amount0Out *big.Int, amount1Out *big.Int, to common.Address, data []byte) (*types.Transaction, error) { | |
| return _UniswapV2Pair.contract.Transact(opts, "swap", amount0Out, amount1Out, to, data) | |
| } | |
| // Swap is a paid mutator transaction binding the contract method 0x022c0d9f. | |
| // | |
| // Solidity: function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes data) returns() | |
| func (_UniswapV2Pair *UniswapV2PairSession) Swap(amount0Out *big.Int, amount1Out *big.Int, to common.Address, data []byte) (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.Swap(&_UniswapV2Pair.TransactOpts, amount0Out, amount1Out, to, data) | |
| } | |
| // Swap is a paid mutator transaction binding the contract method 0x022c0d9f. | |
| // | |
| // Solidity: function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes data) returns() | |
| func (_UniswapV2Pair *UniswapV2PairTransactorSession) Swap(amount0Out *big.Int, amount1Out *big.Int, to common.Address, data []byte) (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.Swap(&_UniswapV2Pair.TransactOpts, amount0Out, amount1Out, to, data) | |
| } | |
| // Sync is a paid mutator transaction binding the contract method 0xfff6cae9. | |
| // | |
| // Solidity: function sync() returns() | |
| func (_UniswapV2Pair *UniswapV2PairTransactor) Sync(opts *bind.TransactOpts) (*types.Transaction, error) { | |
| return _UniswapV2Pair.contract.Transact(opts, "sync") | |
| } | |
| // Sync is a paid mutator transaction binding the contract method 0xfff6cae9. | |
| // | |
| // Solidity: function sync() returns() | |
| func (_UniswapV2Pair *UniswapV2PairSession) Sync() (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.Sync(&_UniswapV2Pair.TransactOpts) | |
| } | |
| // Sync is a paid mutator transaction binding the contract method 0xfff6cae9. | |
| // | |
| // Solidity: function sync() returns() | |
| func (_UniswapV2Pair *UniswapV2PairTransactorSession) Sync() (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.Sync(&_UniswapV2Pair.TransactOpts) | |
| } | |
| // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. | |
| // | |
| // Solidity: function transfer(address to, uint256 value) returns(bool) | |
| func (_UniswapV2Pair *UniswapV2PairTransactor) Transfer(opts *bind.TransactOpts, to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _UniswapV2Pair.contract.Transact(opts, "transfer", to, value) | |
| } | |
| // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. | |
| // | |
| // Solidity: function transfer(address to, uint256 value) returns(bool) | |
| func (_UniswapV2Pair *UniswapV2PairSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.Transfer(&_UniswapV2Pair.TransactOpts, to, value) | |
| } | |
| // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. | |
| // | |
| // Solidity: function transfer(address to, uint256 value) returns(bool) | |
| func (_UniswapV2Pair *UniswapV2PairTransactorSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.Transfer(&_UniswapV2Pair.TransactOpts, to, value) | |
| } | |
| // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. | |
| // | |
| // Solidity: function transferFrom(address from, address to, uint256 value) returns(bool) | |
| func (_UniswapV2Pair *UniswapV2PairTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _UniswapV2Pair.contract.Transact(opts, "transferFrom", from, to, value) | |
| } | |
| // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. | |
| // | |
| // Solidity: function transferFrom(address from, address to, uint256 value) returns(bool) | |
| func (_UniswapV2Pair *UniswapV2PairSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.TransferFrom(&_UniswapV2Pair.TransactOpts, from, to, value) | |
| } | |
| // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. | |
| // | |
| // Solidity: function transferFrom(address from, address to, uint256 value) returns(bool) | |
| func (_UniswapV2Pair *UniswapV2PairTransactorSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { | |
| return _UniswapV2Pair.Contract.TransferFrom(&_UniswapV2Pair.TransactOpts, from, to, value) | |
| } | |
| // UniswapV2PairApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the UniswapV2Pair contract. | |
| type UniswapV2PairApprovalIterator struct { | |
| Event *UniswapV2PairApproval // 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 *UniswapV2PairApprovalIterator) 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(UniswapV2PairApproval) | |
| 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(UniswapV2PairApproval) | |
| 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 *UniswapV2PairApprovalIterator) Error() error { | |
| return it.fail | |
| } | |
| // Close terminates the iteration process, releasing any pending underlying | |
| // resources. | |
| func (it *UniswapV2PairApprovalIterator) Close() error { | |
| it.sub.Unsubscribe() | |
| return nil | |
| } | |
| // UniswapV2PairApproval represents a Approval event raised by the UniswapV2Pair contract. | |
| type UniswapV2PairApproval struct { | |
| Owner common.Address | |
| Spender common.Address | |
| Value *big.Int | |
| Raw types.Log // Blockchain specific contextual infos | |
| } | |
| // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. | |
| // | |
| // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) | |
| func (_UniswapV2Pair *UniswapV2PairFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*UniswapV2PairApprovalIterator, error) { | |
| var ownerRule []interface{} | |
| for _, ownerItem := range owner { | |
| ownerRule = append(ownerRule, ownerItem) | |
| } | |
| var spenderRule []interface{} | |
| for _, spenderItem := range spender { | |
| spenderRule = append(spenderRule, spenderItem) | |
| } | |
| logs, sub, err := _UniswapV2Pair.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &UniswapV2PairApprovalIterator{contract: _UniswapV2Pair.contract, event: "Approval", logs: logs, sub: sub}, nil | |
| } | |
| // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. | |
| // | |
| // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) | |
| func (_UniswapV2Pair *UniswapV2PairFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *UniswapV2PairApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { | |
| var ownerRule []interface{} | |
| for _, ownerItem := range owner { | |
| ownerRule = append(ownerRule, ownerItem) | |
| } | |
| var spenderRule []interface{} | |
| for _, spenderItem := range spender { | |
| spenderRule = append(spenderRule, spenderItem) | |
| } | |
| logs, sub, err := _UniswapV2Pair.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) | |
| 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(UniswapV2PairApproval) | |
| if err := _UniswapV2Pair.contract.UnpackLog(event, "Approval", 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 | |
| } | |
| // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. | |
| // | |
| // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) | |
| func (_UniswapV2Pair *UniswapV2PairFilterer) ParseApproval(log types.Log) (*UniswapV2PairApproval, error) { | |
| event := new(UniswapV2PairApproval) | |
| if err := _UniswapV2Pair.contract.UnpackLog(event, "Approval", log); err != nil { | |
| return nil, err | |
| } | |
| return event, nil | |
| } | |
| // UniswapV2PairBurnIterator is returned from FilterBurn and is used to iterate over the raw logs and unpacked data for Burn events raised by the UniswapV2Pair contract. | |
| type UniswapV2PairBurnIterator struct { | |
| Event *UniswapV2PairBurn // 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 *UniswapV2PairBurnIterator) 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(UniswapV2PairBurn) | |
| 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(UniswapV2PairBurn) | |
| 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 *UniswapV2PairBurnIterator) Error() error { | |
| return it.fail | |
| } | |
| // Close terminates the iteration process, releasing any pending underlying | |
| // resources. | |
| func (it *UniswapV2PairBurnIterator) Close() error { | |
| it.sub.Unsubscribe() | |
| return nil | |
| } | |
| // UniswapV2PairBurn represents a Burn event raised by the UniswapV2Pair contract. | |
| type UniswapV2PairBurn struct { | |
| Sender common.Address | |
| Amount0 *big.Int | |
| Amount1 *big.Int | |
| To common.Address | |
| Raw types.Log // Blockchain specific contextual infos | |
| } | |
| // FilterBurn is a free log retrieval operation binding the contract event 0xdccd412f0b1252819cb1fd330b93224ca42612892bb3f4f789976e6d81936496. | |
| // | |
| // Solidity: event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to) | |
| func (_UniswapV2Pair *UniswapV2PairFilterer) FilterBurn(opts *bind.FilterOpts, sender []common.Address, to []common.Address) (*UniswapV2PairBurnIterator, error) { | |
| var senderRule []interface{} | |
| for _, senderItem := range sender { | |
| senderRule = append(senderRule, senderItem) | |
| } | |
| var toRule []interface{} | |
| for _, toItem := range to { | |
| toRule = append(toRule, toItem) | |
| } | |
| logs, sub, err := _UniswapV2Pair.contract.FilterLogs(opts, "Burn", senderRule, toRule) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &UniswapV2PairBurnIterator{contract: _UniswapV2Pair.contract, event: "Burn", logs: logs, sub: sub}, nil | |
| } | |
| // WatchBurn is a free log subscription operation binding the contract event 0xdccd412f0b1252819cb1fd330b93224ca42612892bb3f4f789976e6d81936496. | |
| // | |
| // Solidity: event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to) | |
| func (_UniswapV2Pair *UniswapV2PairFilterer) WatchBurn(opts *bind.WatchOpts, sink chan<- *UniswapV2PairBurn, sender []common.Address, to []common.Address) (event.Subscription, error) { | |
| var senderRule []interface{} | |
| for _, senderItem := range sender { | |
| senderRule = append(senderRule, senderItem) | |
| } | |
| var toRule []interface{} | |
| for _, toItem := range to { | |
| toRule = append(toRule, toItem) | |
| } | |
| logs, sub, err := _UniswapV2Pair.contract.WatchLogs(opts, "Burn", senderRule, toRule) | |
| 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(UniswapV2PairBurn) | |
| if err := _UniswapV2Pair.contract.UnpackLog(event, "Burn", 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 | |
| } | |
| // ParseBurn is a log parse operation binding the contract event 0xdccd412f0b1252819cb1fd330b93224ca42612892bb3f4f789976e6d81936496. | |
| // | |
| // Solidity: event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to) | |
| func (_UniswapV2Pair *UniswapV2PairFilterer) ParseBurn(log types.Log) (*UniswapV2PairBurn, error) { | |
| event := new(UniswapV2PairBurn) | |
| if err := _UniswapV2Pair.contract.UnpackLog(event, "Burn", log); err != nil { | |
| return nil, err | |
| } | |
| return event, nil | |
| } | |
| // UniswapV2PairMintIterator is returned from FilterMint and is used to iterate over the raw logs and unpacked data for Mint events raised by the UniswapV2Pair contract. | |
| type UniswapV2PairMintIterator struct { | |
| Event *UniswapV2PairMint // 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 *UniswapV2PairMintIterator) 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(UniswapV2PairMint) | |
| 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(UniswapV2PairMint) | |
| 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 *UniswapV2PairMintIterator) Error() error { | |
| return it.fail | |
| } | |
| // Close terminates the iteration process, releasing any pending underlying | |
| // resources. | |
| func (it *UniswapV2PairMintIterator) Close() error { | |
| it.sub.Unsubscribe() | |
| return nil | |
| } | |
| // UniswapV2PairMint represents a Mint event raised by the UniswapV2Pair contract. | |
| type UniswapV2PairMint struct { | |
| Sender common.Address | |
| Amount0 *big.Int | |
| Amount1 *big.Int | |
| Raw types.Log // Blockchain specific contextual infos | |
| } | |
| // FilterMint is a free log retrieval operation binding the contract event 0x4c209b5fc8ad50758f13e2e1088ba56a560dff690a1c6fef26394f4c03821c4f. | |
| // | |
| // Solidity: event Mint(address indexed sender, uint256 amount0, uint256 amount1) | |
| func (_UniswapV2Pair *UniswapV2PairFilterer) FilterMint(opts *bind.FilterOpts, sender []common.Address) (*UniswapV2PairMintIterator, error) { | |
| var senderRule []interface{} | |
| for _, senderItem := range sender { | |
| senderRule = append(senderRule, senderItem) | |
| } | |
| logs, sub, err := _UniswapV2Pair.contract.FilterLogs(opts, "Mint", senderRule) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &UniswapV2PairMintIterator{contract: _UniswapV2Pair.contract, event: "Mint", logs: logs, sub: sub}, nil | |
| } | |
| // WatchMint is a free log subscription operation binding the contract event 0x4c209b5fc8ad50758f13e2e1088ba56a560dff690a1c6fef26394f4c03821c4f. | |
| // | |
| // Solidity: event Mint(address indexed sender, uint256 amount0, uint256 amount1) | |
| func (_UniswapV2Pair *UniswapV2PairFilterer) WatchMint(opts *bind.WatchOpts, sink chan<- *UniswapV2PairMint, sender []common.Address) (event.Subscription, error) { | |
| var senderRule []interface{} | |
| for _, senderItem := range sender { | |
| senderRule = append(senderRule, senderItem) | |
| } | |
| logs, sub, err := _UniswapV2Pair.contract.WatchLogs(opts, "Mint", senderRule) | |
| 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(UniswapV2PairMint) | |
| if err := _UniswapV2Pair.contract.UnpackLog(event, "Mint", 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 | |
| } | |
| // ParseMint is a log parse operation binding the contract event 0x4c209b5fc8ad50758f13e2e1088ba56a560dff690a1c6fef26394f4c03821c4f. | |
| // | |
| // Solidity: event Mint(address indexed sender, uint256 amount0, uint256 amount1) | |
| func (_UniswapV2Pair *UniswapV2PairFilterer) ParseMint(log types.Log) (*UniswapV2PairMint, error) { | |
| event := new(UniswapV2PairMint) | |
| if err := _UniswapV2Pair.contract.UnpackLog(event, "Mint", log); err != nil { | |
| return nil, err | |
| } | |
| return event, nil | |
| } | |
| // UniswapV2PairSwapIterator is returned from FilterSwap and is used to iterate over the raw logs and unpacked data for Swap events raised by the UniswapV2Pair contract. | |
| type UniswapV2PairSwapIterator struct { | |
| Event *UniswapV2PairSwap // 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 *UniswapV2PairSwapIterator) 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(UniswapV2PairSwap) | |
| 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(UniswapV2PairSwap) | |
| 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 *UniswapV2PairSwapIterator) Error() error { | |
| return it.fail | |
| } | |
| // Close terminates the iteration process, releasing any pending underlying | |
| // resources. | |
| func (it *UniswapV2PairSwapIterator) Close() error { | |
| it.sub.Unsubscribe() | |
| return nil | |
| } | |
| // UniswapV2PairSwap represents a Swap event raised by the UniswapV2Pair contract. | |
| type UniswapV2PairSwap struct { | |
| Sender common.Address | |
| Amount0In *big.Int | |
| Amount1In *big.Int | |
| Amount0Out *big.Int | |
| Amount1Out *big.Int | |
| To common.Address | |
| Raw types.Log // Blockchain specific contextual infos | |
| } | |
| // FilterSwap is a free log retrieval operation binding the contract event 0xd78ad95fa46c994b6551d0da85fc275fe613ce37657fb8d5e3d130840159d822. | |
| // | |
| // Solidity: event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to) | |
| func (_UniswapV2Pair *UniswapV2PairFilterer) FilterSwap(opts *bind.FilterOpts, sender []common.Address, to []common.Address) (*UniswapV2PairSwapIterator, error) { | |
| var senderRule []interface{} | |
| for _, senderItem := range sender { | |
| senderRule = append(senderRule, senderItem) | |
| } | |
| var toRule []interface{} | |
| for _, toItem := range to { | |
| toRule = append(toRule, toItem) | |
| } | |
| logs, sub, err := _UniswapV2Pair.contract.FilterLogs(opts, "Swap", senderRule, toRule) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &UniswapV2PairSwapIterator{contract: _UniswapV2Pair.contract, event: "Swap", logs: logs, sub: sub}, nil | |
| } | |
| // WatchSwap is a free log subscription operation binding the contract event 0xd78ad95fa46c994b6551d0da85fc275fe613ce37657fb8d5e3d130840159d822. | |
| // | |
| // Solidity: event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to) | |
| func (_UniswapV2Pair *UniswapV2PairFilterer) WatchSwap(opts *bind.WatchOpts, sink chan<- *UniswapV2PairSwap, sender []common.Address, to []common.Address) (event.Subscription, error) { | |
| var senderRule []interface{} | |
| for _, senderItem := range sender { | |
| senderRule = append(senderRule, senderItem) | |
| } | |
| var toRule []interface{} | |
| for _, toItem := range to { | |
| toRule = append(toRule, toItem) | |
| } | |
| logs, sub, err := _UniswapV2Pair.contract.WatchLogs(opts, "Swap", senderRule, toRule) | |
| 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(UniswapV2PairSwap) | |
| if err := _UniswapV2Pair.contract.UnpackLog(event, "Swap", 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 | |
| } | |
| // ParseSwap is a log parse operation binding the contract event 0xd78ad95fa46c994b6551d0da85fc275fe613ce37657fb8d5e3d130840159d822. | |
| // | |
| // Solidity: event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to) | |
| func (_UniswapV2Pair *UniswapV2PairFilterer) ParseSwap(log types.Log) (*UniswapV2PairSwap, error) { | |
| event := new(UniswapV2PairSwap) | |
| if err := _UniswapV2Pair.contract.UnpackLog(event, "Swap", log); err != nil { | |
| return nil, err | |
| } | |
| return event, nil | |
| } | |
| // UniswapV2PairSyncIterator is returned from FilterSync and is used to iterate over the raw logs and unpacked data for Sync events raised by the UniswapV2Pair contract. | |
| type UniswapV2PairSyncIterator struct { | |
| Event *UniswapV2PairSync // 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 *UniswapV2PairSyncIterator) 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(UniswapV2PairSync) | |
| 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(UniswapV2PairSync) | |
| 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 *UniswapV2PairSyncIterator) Error() error { | |
| return it.fail | |
| } | |
| // Close terminates the iteration process, releasing any pending underlying | |
| // resources. | |
| func (it *UniswapV2PairSyncIterator) Close() error { | |
| it.sub.Unsubscribe() | |
| return nil | |
| } | |
| // UniswapV2PairSync represents a Sync event raised by the UniswapV2Pair contract. | |
| type UniswapV2PairSync struct { | |
| Reserve0 *big.Int | |
| Reserve1 *big.Int | |
| Raw types.Log // Blockchain specific contextual infos | |
| } | |
| // FilterSync is a free log retrieval operation binding the contract event 0x1c411e9a96e071241c2f21f7726b17ae89e3cab4c78be50e062b03a9fffbbad1. | |
| // | |
| // Solidity: event Sync(uint112 reserve0, uint112 reserve1) | |
| func (_UniswapV2Pair *UniswapV2PairFilterer) FilterSync(opts *bind.FilterOpts) (*UniswapV2PairSyncIterator, error) { | |
| logs, sub, err := _UniswapV2Pair.contract.FilterLogs(opts, "Sync") | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &UniswapV2PairSyncIterator{contract: _UniswapV2Pair.contract, event: "Sync", logs: logs, sub: sub}, nil | |
| } | |
| // WatchSync is a free log subscription operation binding the contract event 0x1c411e9a96e071241c2f21f7726b17ae89e3cab4c78be50e062b03a9fffbbad1. | |
| // | |
| // Solidity: event Sync(uint112 reserve0, uint112 reserve1) | |
| func (_UniswapV2Pair *UniswapV2PairFilterer) WatchSync(opts *bind.WatchOpts, sink chan<- *UniswapV2PairSync) (event.Subscription, error) { | |
| logs, sub, err := _UniswapV2Pair.contract.WatchLogs(opts, "Sync") | |
| 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(UniswapV2PairSync) | |
| if err := _UniswapV2Pair.contract.UnpackLog(event, "Sync", 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 | |
| } | |
| // ParseSync is a log parse operation binding the contract event 0x1c411e9a96e071241c2f21f7726b17ae89e3cab4c78be50e062b03a9fffbbad1. | |
| // | |
| // Solidity: event Sync(uint112 reserve0, uint112 reserve1) | |
| func (_UniswapV2Pair *UniswapV2PairFilterer) ParseSync(log types.Log) (*UniswapV2PairSync, error) { | |
| event := new(UniswapV2PairSync) | |
| if err := _UniswapV2Pair.contract.UnpackLog(event, "Sync", log); err != nil { | |
| return nil, err | |
| } | |
| return event, nil | |
| } | |
| // UniswapV2PairTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the UniswapV2Pair contract. | |
| type UniswapV2PairTransferIterator struct { | |
| Event *UniswapV2PairTransfer // 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 *UniswapV2PairTransferIterator) 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(UniswapV2PairTransfer) | |
| 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(UniswapV2PairTransfer) | |
| 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 *UniswapV2PairTransferIterator) Error() error { | |
| return it.fail | |
| } | |
| // Close terminates the iteration process, releasing any pending underlying | |
| // resources. | |
| func (it *UniswapV2PairTransferIterator) Close() error { | |
| it.sub.Unsubscribe() | |
| return nil | |
| } | |
| // UniswapV2PairTransfer represents a Transfer event raised by the UniswapV2Pair contract. | |
| type UniswapV2PairTransfer struct { | |
| From common.Address | |
| To common.Address | |
| Value *big.Int | |
| Raw types.Log // Blockchain specific contextual infos | |
| } | |
| // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. | |
| // | |
| // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) | |
| func (_UniswapV2Pair *UniswapV2PairFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*UniswapV2PairTransferIterator, error) { | |
| var fromRule []interface{} | |
| for _, fromItem := range from { | |
| fromRule = append(fromRule, fromItem) | |
| } | |
| var toRule []interface{} | |
| for _, toItem := range to { | |
| toRule = append(toRule, toItem) | |
| } | |
| logs, sub, err := _UniswapV2Pair.contract.FilterLogs(opts, "Transfer", fromRule, toRule) | |
| if err != nil { | |
| return nil, err | |
| } | |
| return &UniswapV2PairTransferIterator{contract: _UniswapV2Pair.contract, event: "Transfer", logs: logs, sub: sub}, nil | |
| } | |
| // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. | |
| // | |
| // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) | |
| func (_UniswapV2Pair *UniswapV2PairFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *UniswapV2PairTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { | |
| var fromRule []interface{} | |
| for _, fromItem := range from { | |
| fromRule = append(fromRule, fromItem) | |
| } | |
| var toRule []interface{} | |
| for _, toItem := range to { | |
| toRule = append(toRule, toItem) | |
| } | |
| logs, sub, err := _UniswapV2Pair.contract.WatchLogs(opts, "Transfer", fromRule, toRule) | |
| 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(UniswapV2PairTransfer) | |
| if err := _UniswapV2Pair.contract.UnpackLog(event, "Transfer", 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 | |
| } | |
| // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. | |
| // | |
| // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) | |
| func (_UniswapV2Pair *UniswapV2PairFilterer) ParseTransfer(log types.Log) (*UniswapV2PairTransfer, error) { | |
| event := new(UniswapV2PairTransfer) | |
| if err := _UniswapV2Pair.contract.UnpackLog(event, "Transfer", log); err != nil { | |
| return nil, err | |
| } | |
| return event, nil | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment