15500 lines
667 KiB
Go
15500 lines
667 KiB
Go
// Code generated - DO NOT EDIT.
|
|
// This file is a generated binding and any manual changes will be lost.
|
|
|
|
package stickers
|
|
|
|
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
|
|
)
|
|
|
|
// ApproveAndCallFallBackABI is the input ABI used to generate the binding from.
|
|
const ApproveAndCallFallBackABI = "[{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"_amount\",\"type\":\"uint256\"},{\"name\":\"_token\",\"type\":\"address\"},{\"name\":\"_data\",\"type\":\"bytes\"}],\"name\":\"receiveApproval\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"
|
|
|
|
// ApproveAndCallFallBackFuncSigs maps the 4-byte function signature to its string representation.
|
|
var ApproveAndCallFallBackFuncSigs = map[string]string{
|
|
"8f4ffcb1": "receiveApproval(address,uint256,address,bytes)",
|
|
}
|
|
|
|
// ApproveAndCallFallBack is an auto generated Go binding around an Ethereum contract.
|
|
type ApproveAndCallFallBack struct {
|
|
ApproveAndCallFallBackCaller // Read-only binding to the contract
|
|
ApproveAndCallFallBackTransactor // Write-only binding to the contract
|
|
ApproveAndCallFallBackFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// ApproveAndCallFallBackCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type ApproveAndCallFallBackCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ApproveAndCallFallBackTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type ApproveAndCallFallBackTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ApproveAndCallFallBackFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type ApproveAndCallFallBackFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ApproveAndCallFallBackSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type ApproveAndCallFallBackSession struct {
|
|
Contract *ApproveAndCallFallBack // 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
|
|
}
|
|
|
|
// ApproveAndCallFallBackCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type ApproveAndCallFallBackCallerSession struct {
|
|
Contract *ApproveAndCallFallBackCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// ApproveAndCallFallBackTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type ApproveAndCallFallBackTransactorSession struct {
|
|
Contract *ApproveAndCallFallBackTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// ApproveAndCallFallBackRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type ApproveAndCallFallBackRaw struct {
|
|
Contract *ApproveAndCallFallBack // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// ApproveAndCallFallBackCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type ApproveAndCallFallBackCallerRaw struct {
|
|
Contract *ApproveAndCallFallBackCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// ApproveAndCallFallBackTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type ApproveAndCallFallBackTransactorRaw struct {
|
|
Contract *ApproveAndCallFallBackTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewApproveAndCallFallBack creates a new instance of ApproveAndCallFallBack, bound to a specific deployed contract.
|
|
func NewApproveAndCallFallBack(address common.Address, backend bind.ContractBackend) (*ApproveAndCallFallBack, error) {
|
|
contract, err := bindApproveAndCallFallBack(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ApproveAndCallFallBack{ApproveAndCallFallBackCaller: ApproveAndCallFallBackCaller{contract: contract}, ApproveAndCallFallBackTransactor: ApproveAndCallFallBackTransactor{contract: contract}, ApproveAndCallFallBackFilterer: ApproveAndCallFallBackFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewApproveAndCallFallBackCaller creates a new read-only instance of ApproveAndCallFallBack, bound to a specific deployed contract.
|
|
func NewApproveAndCallFallBackCaller(address common.Address, caller bind.ContractCaller) (*ApproveAndCallFallBackCaller, error) {
|
|
contract, err := bindApproveAndCallFallBack(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ApproveAndCallFallBackCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewApproveAndCallFallBackTransactor creates a new write-only instance of ApproveAndCallFallBack, bound to a specific deployed contract.
|
|
func NewApproveAndCallFallBackTransactor(address common.Address, transactor bind.ContractTransactor) (*ApproveAndCallFallBackTransactor, error) {
|
|
contract, err := bindApproveAndCallFallBack(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ApproveAndCallFallBackTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewApproveAndCallFallBackFilterer creates a new log filterer instance of ApproveAndCallFallBack, bound to a specific deployed contract.
|
|
func NewApproveAndCallFallBackFilterer(address common.Address, filterer bind.ContractFilterer) (*ApproveAndCallFallBackFilterer, error) {
|
|
contract, err := bindApproveAndCallFallBack(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ApproveAndCallFallBackFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindApproveAndCallFallBack binds a generic wrapper to an already deployed contract.
|
|
func bindApproveAndCallFallBack(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(ApproveAndCallFallBackABI))
|
|
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 (_ApproveAndCallFallBack *ApproveAndCallFallBackRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ApproveAndCallFallBack.Contract.ApproveAndCallFallBackCaller.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 (_ApproveAndCallFallBack *ApproveAndCallFallBackRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ApproveAndCallFallBack.Contract.ApproveAndCallFallBackTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ApproveAndCallFallBack *ApproveAndCallFallBackRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ApproveAndCallFallBack.Contract.ApproveAndCallFallBackTransactor.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 (_ApproveAndCallFallBack *ApproveAndCallFallBackCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ApproveAndCallFallBack.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 (_ApproveAndCallFallBack *ApproveAndCallFallBackTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ApproveAndCallFallBack.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ApproveAndCallFallBack *ApproveAndCallFallBackTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ApproveAndCallFallBack.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// ReceiveApproval is a paid mutator transaction binding the contract method 0x8f4ffcb1.
|
|
//
|
|
// Solidity: function receiveApproval(address from, uint256 _amount, address _token, bytes _data) returns()
|
|
func (_ApproveAndCallFallBack *ApproveAndCallFallBackTransactor) ReceiveApproval(opts *bind.TransactOpts, from common.Address, _amount *big.Int, _token common.Address, _data []byte) (*types.Transaction, error) {
|
|
return _ApproveAndCallFallBack.contract.Transact(opts, "receiveApproval", from, _amount, _token, _data)
|
|
}
|
|
|
|
// ReceiveApproval is a paid mutator transaction binding the contract method 0x8f4ffcb1.
|
|
//
|
|
// Solidity: function receiveApproval(address from, uint256 _amount, address _token, bytes _data) returns()
|
|
func (_ApproveAndCallFallBack *ApproveAndCallFallBackSession) ReceiveApproval(from common.Address, _amount *big.Int, _token common.Address, _data []byte) (*types.Transaction, error) {
|
|
return _ApproveAndCallFallBack.Contract.ReceiveApproval(&_ApproveAndCallFallBack.TransactOpts, from, _amount, _token, _data)
|
|
}
|
|
|
|
// ReceiveApproval is a paid mutator transaction binding the contract method 0x8f4ffcb1.
|
|
//
|
|
// Solidity: function receiveApproval(address from, uint256 _amount, address _token, bytes _data) returns()
|
|
func (_ApproveAndCallFallBack *ApproveAndCallFallBackTransactorSession) ReceiveApproval(from common.Address, _amount *big.Int, _token common.Address, _data []byte) (*types.Transaction, error) {
|
|
return _ApproveAndCallFallBack.Contract.ReceiveApproval(&_ApproveAndCallFallBack.TransactOpts, from, _amount, _token, _data)
|
|
}
|
|
|
|
// ControlledABI is the input ABI used to generate the binding from.
|
|
const ControlledABI = "[{\"constant\":false,\"inputs\":[{\"name\":\"_newController\",\"type\":\"address\"}],\"name\":\"changeController\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"controller\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"controller\",\"type\":\"address\"}],\"name\":\"NewController\",\"type\":\"event\"}]"
|
|
|
|
// ControlledFuncSigs maps the 4-byte function signature to its string representation.
|
|
var ControlledFuncSigs = map[string]string{
|
|
"3cebb823": "changeController(address)",
|
|
"f77c4791": "controller()",
|
|
}
|
|
|
|
// Controlled is an auto generated Go binding around an Ethereum contract.
|
|
type Controlled struct {
|
|
ControlledCaller // Read-only binding to the contract
|
|
ControlledTransactor // Write-only binding to the contract
|
|
ControlledFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// ControlledCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type ControlledCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ControlledTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type ControlledTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ControlledFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type ControlledFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ControlledSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type ControlledSession struct {
|
|
Contract *Controlled // 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
|
|
}
|
|
|
|
// ControlledCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type ControlledCallerSession struct {
|
|
Contract *ControlledCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// ControlledTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type ControlledTransactorSession struct {
|
|
Contract *ControlledTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// ControlledRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type ControlledRaw struct {
|
|
Contract *Controlled // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// ControlledCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type ControlledCallerRaw struct {
|
|
Contract *ControlledCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// ControlledTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type ControlledTransactorRaw struct {
|
|
Contract *ControlledTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewControlled creates a new instance of Controlled, bound to a specific deployed contract.
|
|
func NewControlled(address common.Address, backend bind.ContractBackend) (*Controlled, error) {
|
|
contract, err := bindControlled(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &Controlled{ControlledCaller: ControlledCaller{contract: contract}, ControlledTransactor: ControlledTransactor{contract: contract}, ControlledFilterer: ControlledFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewControlledCaller creates a new read-only instance of Controlled, bound to a specific deployed contract.
|
|
func NewControlledCaller(address common.Address, caller bind.ContractCaller) (*ControlledCaller, error) {
|
|
contract, err := bindControlled(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ControlledCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewControlledTransactor creates a new write-only instance of Controlled, bound to a specific deployed contract.
|
|
func NewControlledTransactor(address common.Address, transactor bind.ContractTransactor) (*ControlledTransactor, error) {
|
|
contract, err := bindControlled(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ControlledTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewControlledFilterer creates a new log filterer instance of Controlled, bound to a specific deployed contract.
|
|
func NewControlledFilterer(address common.Address, filterer bind.ContractFilterer) (*ControlledFilterer, error) {
|
|
contract, err := bindControlled(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ControlledFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindControlled binds a generic wrapper to an already deployed contract.
|
|
func bindControlled(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(ControlledABI))
|
|
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 (_Controlled *ControlledRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _Controlled.Contract.ControlledCaller.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 (_Controlled *ControlledRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _Controlled.Contract.ControlledTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_Controlled *ControlledRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _Controlled.Contract.ControlledTransactor.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 (_Controlled *ControlledCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _Controlled.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 (_Controlled *ControlledTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _Controlled.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_Controlled *ControlledTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _Controlled.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// Controller is a free data retrieval call binding the contract method 0xf77c4791.
|
|
//
|
|
// Solidity: function controller() view returns(address)
|
|
func (_Controlled *ControlledCaller) Controller(opts *bind.CallOpts) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _Controlled.contract.Call(opts, &out, "controller")
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Controller is a free data retrieval call binding the contract method 0xf77c4791.
|
|
//
|
|
// Solidity: function controller() view returns(address)
|
|
func (_Controlled *ControlledSession) Controller() (common.Address, error) {
|
|
return _Controlled.Contract.Controller(&_Controlled.CallOpts)
|
|
}
|
|
|
|
// Controller is a free data retrieval call binding the contract method 0xf77c4791.
|
|
//
|
|
// Solidity: function controller() view returns(address)
|
|
func (_Controlled *ControlledCallerSession) Controller() (common.Address, error) {
|
|
return _Controlled.Contract.Controller(&_Controlled.CallOpts)
|
|
}
|
|
|
|
// ChangeController is a paid mutator transaction binding the contract method 0x3cebb823.
|
|
//
|
|
// Solidity: function changeController(address _newController) returns()
|
|
func (_Controlled *ControlledTransactor) ChangeController(opts *bind.TransactOpts, _newController common.Address) (*types.Transaction, error) {
|
|
return _Controlled.contract.Transact(opts, "changeController", _newController)
|
|
}
|
|
|
|
// ChangeController is a paid mutator transaction binding the contract method 0x3cebb823.
|
|
//
|
|
// Solidity: function changeController(address _newController) returns()
|
|
func (_Controlled *ControlledSession) ChangeController(_newController common.Address) (*types.Transaction, error) {
|
|
return _Controlled.Contract.ChangeController(&_Controlled.TransactOpts, _newController)
|
|
}
|
|
|
|
// ChangeController is a paid mutator transaction binding the contract method 0x3cebb823.
|
|
//
|
|
// Solidity: function changeController(address _newController) returns()
|
|
func (_Controlled *ControlledTransactorSession) ChangeController(_newController common.Address) (*types.Transaction, error) {
|
|
return _Controlled.Contract.ChangeController(&_Controlled.TransactOpts, _newController)
|
|
}
|
|
|
|
// ControlledNewControllerIterator is returned from FilterNewController and is used to iterate over the raw logs and unpacked data for NewController events raised by the Controlled contract.
|
|
type ControlledNewControllerIterator struct {
|
|
Event *ControlledNewController // 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 *ControlledNewControllerIterator) 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(ControlledNewController)
|
|
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(ControlledNewController)
|
|
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 *ControlledNewControllerIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ControlledNewControllerIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ControlledNewController represents a NewController event raised by the Controlled contract.
|
|
type ControlledNewController struct {
|
|
Controller common.Address
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterNewController is a free log retrieval operation binding the contract event 0xe253457d9ad994ca9682fc3bbc38c890dca73a2d5ecee3809e548bac8b00d7c6.
|
|
//
|
|
// Solidity: event NewController(address controller)
|
|
func (_Controlled *ControlledFilterer) FilterNewController(opts *bind.FilterOpts) (*ControlledNewControllerIterator, error) {
|
|
|
|
logs, sub, err := _Controlled.contract.FilterLogs(opts, "NewController")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ControlledNewControllerIterator{contract: _Controlled.contract, event: "NewController", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchNewController is a free log subscription operation binding the contract event 0xe253457d9ad994ca9682fc3bbc38c890dca73a2d5ecee3809e548bac8b00d7c6.
|
|
//
|
|
// Solidity: event NewController(address controller)
|
|
func (_Controlled *ControlledFilterer) WatchNewController(opts *bind.WatchOpts, sink chan<- *ControlledNewController) (event.Subscription, error) {
|
|
|
|
logs, sub, err := _Controlled.contract.WatchLogs(opts, "NewController")
|
|
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(ControlledNewController)
|
|
if err := _Controlled.contract.UnpackLog(event, "NewController", 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
|
|
}
|
|
|
|
// ParseNewController is a log parse operation binding the contract event 0xe253457d9ad994ca9682fc3bbc38c890dca73a2d5ecee3809e548bac8b00d7c6.
|
|
//
|
|
// Solidity: event NewController(address controller)
|
|
func (_Controlled *ControlledFilterer) ParseNewController(log types.Log) (*ControlledNewController, error) {
|
|
event := new(ControlledNewController)
|
|
if err := _Controlled.contract.UnpackLog(event, "NewController", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ERC165ABI is the input ABI used to generate the binding from.
|
|
const ERC165ABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"
|
|
|
|
// ERC165FuncSigs maps the 4-byte function signature to its string representation.
|
|
var ERC165FuncSigs = map[string]string{
|
|
"01ffc9a7": "supportsInterface(bytes4)",
|
|
}
|
|
|
|
// ERC165 is an auto generated Go binding around an Ethereum contract.
|
|
type ERC165 struct {
|
|
ERC165Caller // Read-only binding to the contract
|
|
ERC165Transactor // Write-only binding to the contract
|
|
ERC165Filterer // Log filterer for contract events
|
|
}
|
|
|
|
// ERC165Caller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type ERC165Caller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ERC165Transactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type ERC165Transactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ERC165Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type ERC165Filterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ERC165Session is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type ERC165Session struct {
|
|
Contract *ERC165 // 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
|
|
}
|
|
|
|
// ERC165CallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type ERC165CallerSession struct {
|
|
Contract *ERC165Caller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// ERC165TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type ERC165TransactorSession struct {
|
|
Contract *ERC165Transactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// ERC165Raw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type ERC165Raw struct {
|
|
Contract *ERC165 // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// ERC165CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type ERC165CallerRaw struct {
|
|
Contract *ERC165Caller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// ERC165TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type ERC165TransactorRaw struct {
|
|
Contract *ERC165Transactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewERC165 creates a new instance of ERC165, bound to a specific deployed contract.
|
|
func NewERC165(address common.Address, backend bind.ContractBackend) (*ERC165, error) {
|
|
contract, err := bindERC165(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC165{ERC165Caller: ERC165Caller{contract: contract}, ERC165Transactor: ERC165Transactor{contract: contract}, ERC165Filterer: ERC165Filterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewERC165Caller creates a new read-only instance of ERC165, bound to a specific deployed contract.
|
|
func NewERC165Caller(address common.Address, caller bind.ContractCaller) (*ERC165Caller, error) {
|
|
contract, err := bindERC165(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC165Caller{contract: contract}, nil
|
|
}
|
|
|
|
// NewERC165Transactor creates a new write-only instance of ERC165, bound to a specific deployed contract.
|
|
func NewERC165Transactor(address common.Address, transactor bind.ContractTransactor) (*ERC165Transactor, error) {
|
|
contract, err := bindERC165(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC165Transactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewERC165Filterer creates a new log filterer instance of ERC165, bound to a specific deployed contract.
|
|
func NewERC165Filterer(address common.Address, filterer bind.ContractFilterer) (*ERC165Filterer, error) {
|
|
contract, err := bindERC165(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC165Filterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindERC165 binds a generic wrapper to an already deployed contract.
|
|
func bindERC165(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(ERC165ABI))
|
|
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 (_ERC165 *ERC165Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ERC165.Contract.ERC165Caller.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 (_ERC165 *ERC165Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ERC165.Contract.ERC165Transactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ERC165 *ERC165Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ERC165.Contract.ERC165Transactor.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 (_ERC165 *ERC165CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ERC165.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 (_ERC165 *ERC165TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ERC165.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ERC165 *ERC165TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ERC165.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_ERC165 *ERC165Caller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _ERC165.contract.Call(opts, &out, "supportsInterface", interfaceId)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_ERC165 *ERC165Session) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _ERC165.Contract.SupportsInterface(&_ERC165.CallOpts, interfaceId)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_ERC165 *ERC165CallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _ERC165.Contract.SupportsInterface(&_ERC165.CallOpts, interfaceId)
|
|
}
|
|
|
|
// ERC721ABI is the input ABI used to generate the binding from.
|
|
const ERC721ABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"getApproved\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"ownerOf\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"},{\"name\":\"_data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"approved\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"}]"
|
|
|
|
// ERC721FuncSigs maps the 4-byte function signature to its string representation.
|
|
var ERC721FuncSigs = map[string]string{
|
|
"095ea7b3": "approve(address,uint256)",
|
|
"70a08231": "balanceOf(address)",
|
|
"081812fc": "getApproved(uint256)",
|
|
"e985e9c5": "isApprovedForAll(address,address)",
|
|
"6352211e": "ownerOf(uint256)",
|
|
"42842e0e": "safeTransferFrom(address,address,uint256)",
|
|
"b88d4fde": "safeTransferFrom(address,address,uint256,bytes)",
|
|
"a22cb465": "setApprovalForAll(address,bool)",
|
|
"01ffc9a7": "supportsInterface(bytes4)",
|
|
"23b872dd": "transferFrom(address,address,uint256)",
|
|
}
|
|
|
|
// ERC721 is an auto generated Go binding around an Ethereum contract.
|
|
type ERC721 struct {
|
|
ERC721Caller // Read-only binding to the contract
|
|
ERC721Transactor // Write-only binding to the contract
|
|
ERC721Filterer // Log filterer for contract events
|
|
}
|
|
|
|
// ERC721Caller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type ERC721Caller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ERC721Transactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type ERC721Transactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ERC721Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type ERC721Filterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ERC721Session is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type ERC721Session struct {
|
|
Contract *ERC721 // 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
|
|
}
|
|
|
|
// ERC721CallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type ERC721CallerSession struct {
|
|
Contract *ERC721Caller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// ERC721TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type ERC721TransactorSession struct {
|
|
Contract *ERC721Transactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// ERC721Raw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type ERC721Raw struct {
|
|
Contract *ERC721 // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// ERC721CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type ERC721CallerRaw struct {
|
|
Contract *ERC721Caller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// ERC721TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type ERC721TransactorRaw struct {
|
|
Contract *ERC721Transactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewERC721 creates a new instance of ERC721, bound to a specific deployed contract.
|
|
func NewERC721(address common.Address, backend bind.ContractBackend) (*ERC721, error) {
|
|
contract, err := bindERC721(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721{ERC721Caller: ERC721Caller{contract: contract}, ERC721Transactor: ERC721Transactor{contract: contract}, ERC721Filterer: ERC721Filterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewERC721Caller creates a new read-only instance of ERC721, bound to a specific deployed contract.
|
|
func NewERC721Caller(address common.Address, caller bind.ContractCaller) (*ERC721Caller, error) {
|
|
contract, err := bindERC721(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721Caller{contract: contract}, nil
|
|
}
|
|
|
|
// NewERC721Transactor creates a new write-only instance of ERC721, bound to a specific deployed contract.
|
|
func NewERC721Transactor(address common.Address, transactor bind.ContractTransactor) (*ERC721Transactor, error) {
|
|
contract, err := bindERC721(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721Transactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewERC721Filterer creates a new log filterer instance of ERC721, bound to a specific deployed contract.
|
|
func NewERC721Filterer(address common.Address, filterer bind.ContractFilterer) (*ERC721Filterer, error) {
|
|
contract, err := bindERC721(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721Filterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindERC721 binds a generic wrapper to an already deployed contract.
|
|
func bindERC721(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(ERC721ABI))
|
|
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 (_ERC721 *ERC721Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ERC721.Contract.ERC721Caller.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 (_ERC721 *ERC721Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ERC721.Contract.ERC721Transactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ERC721 *ERC721Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ERC721.Contract.ERC721Transactor.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 (_ERC721 *ERC721CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ERC721.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 (_ERC721 *ERC721TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ERC721.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ERC721 *ERC721TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ERC721.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address owner) view returns(uint256)
|
|
func (_ERC721 *ERC721Caller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _ERC721.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 (_ERC721 *ERC721Session) BalanceOf(owner common.Address) (*big.Int, error) {
|
|
return _ERC721.Contract.BalanceOf(&_ERC721.CallOpts, owner)
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address owner) view returns(uint256)
|
|
func (_ERC721 *ERC721CallerSession) BalanceOf(owner common.Address) (*big.Int, error) {
|
|
return _ERC721.Contract.BalanceOf(&_ERC721.CallOpts, owner)
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address)
|
|
func (_ERC721 *ERC721Caller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _ERC721.contract.Call(opts, &out, "getApproved", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address)
|
|
func (_ERC721 *ERC721Session) GetApproved(tokenId *big.Int) (common.Address, error) {
|
|
return _ERC721.Contract.GetApproved(&_ERC721.CallOpts, tokenId)
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address)
|
|
func (_ERC721 *ERC721CallerSession) GetApproved(tokenId *big.Int) (common.Address, error) {
|
|
return _ERC721.Contract.GetApproved(&_ERC721.CallOpts, tokenId)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_ERC721 *ERC721Caller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error) {
|
|
var out []interface{}
|
|
err := _ERC721.contract.Call(opts, &out, "isApprovedForAll", owner, operator)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_ERC721 *ERC721Session) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _ERC721.Contract.IsApprovedForAll(&_ERC721.CallOpts, owner, operator)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_ERC721 *ERC721CallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _ERC721.Contract.IsApprovedForAll(&_ERC721.CallOpts, owner, operator)
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address)
|
|
func (_ERC721 *ERC721Caller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _ERC721.contract.Call(opts, &out, "ownerOf", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address)
|
|
func (_ERC721 *ERC721Session) OwnerOf(tokenId *big.Int) (common.Address, error) {
|
|
return _ERC721.Contract.OwnerOf(&_ERC721.CallOpts, tokenId)
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address)
|
|
func (_ERC721 *ERC721CallerSession) OwnerOf(tokenId *big.Int) (common.Address, error) {
|
|
return _ERC721.Contract.OwnerOf(&_ERC721.CallOpts, tokenId)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_ERC721 *ERC721Caller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _ERC721.contract.Call(opts, &out, "supportsInterface", interfaceId)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_ERC721 *ERC721Session) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _ERC721.Contract.SupportsInterface(&_ERC721.CallOpts, interfaceId)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_ERC721 *ERC721CallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _ERC721.Contract.SupportsInterface(&_ERC721.CallOpts, interfaceId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_ERC721 *ERC721Transactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721.contract.Transact(opts, "approve", to, tokenId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_ERC721 *ERC721Session) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721.Contract.Approve(&_ERC721.TransactOpts, to, tokenId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_ERC721 *ERC721TransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721.Contract.Approve(&_ERC721.TransactOpts, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721 *ERC721Transactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721.contract.Transact(opts, "safeTransferFrom", from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721 *ERC721Session) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721.Contract.SafeTransferFrom(&_ERC721.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721 *ERC721TransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721.Contract.SafeTransferFrom(&_ERC721.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes _data) returns()
|
|
func (_ERC721 *ERC721Transactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error) {
|
|
return _ERC721.contract.Transact(opts, "safeTransferFrom0", from, to, tokenId, _data)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes _data) returns()
|
|
func (_ERC721 *ERC721Session) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error) {
|
|
return _ERC721.Contract.SafeTransferFrom0(&_ERC721.TransactOpts, from, to, tokenId, _data)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes _data) returns()
|
|
func (_ERC721 *ERC721TransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error) {
|
|
return _ERC721.Contract.SafeTransferFrom0(&_ERC721.TransactOpts, from, to, tokenId, _data)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address to, bool approved) returns()
|
|
func (_ERC721 *ERC721Transactor) SetApprovalForAll(opts *bind.TransactOpts, to common.Address, approved bool) (*types.Transaction, error) {
|
|
return _ERC721.contract.Transact(opts, "setApprovalForAll", to, approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address to, bool approved) returns()
|
|
func (_ERC721 *ERC721Session) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error) {
|
|
return _ERC721.Contract.SetApprovalForAll(&_ERC721.TransactOpts, to, approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address to, bool approved) returns()
|
|
func (_ERC721 *ERC721TransactorSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error) {
|
|
return _ERC721.Contract.SetApprovalForAll(&_ERC721.TransactOpts, to, approved)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721 *ERC721Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721.contract.Transact(opts, "transferFrom", from, to, tokenId)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721 *ERC721Session) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721.Contract.TransferFrom(&_ERC721.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721 *ERC721TransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721.Contract.TransferFrom(&_ERC721.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// ERC721ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ERC721 contract.
|
|
type ERC721ApprovalIterator struct {
|
|
Event *ERC721Approval // 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 *ERC721ApprovalIterator) 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(ERC721Approval)
|
|
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(ERC721Approval)
|
|
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 *ERC721ApprovalIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ERC721ApprovalIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ERC721Approval represents a Approval event raised by the ERC721 contract.
|
|
type ERC721Approval struct {
|
|
Owner common.Address
|
|
Approved common.Address
|
|
TokenId *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 approved, uint256 indexed tokenId)
|
|
func (_ERC721 *ERC721Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, tokenId []*big.Int) (*ERC721ApprovalIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var approvedRule []interface{}
|
|
for _, approvedItem := range approved {
|
|
approvedRule = append(approvedRule, approvedItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721.contract.FilterLogs(opts, "Approval", ownerRule, approvedRule, tokenIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721ApprovalIterator{contract: _ERC721.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 approved, uint256 indexed tokenId)
|
|
func (_ERC721 *ERC721Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC721Approval, owner []common.Address, approved []common.Address, tokenId []*big.Int) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var approvedRule []interface{}
|
|
for _, approvedItem := range approved {
|
|
approvedRule = append(approvedRule, approvedItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721.contract.WatchLogs(opts, "Approval", ownerRule, approvedRule, tokenIdRule)
|
|
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(ERC721Approval)
|
|
if err := _ERC721.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 approved, uint256 indexed tokenId)
|
|
func (_ERC721 *ERC721Filterer) ParseApproval(log types.Log) (*ERC721Approval, error) {
|
|
event := new(ERC721Approval)
|
|
if err := _ERC721.contract.UnpackLog(event, "Approval", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ERC721ApprovalForAllIterator is returned from FilterApprovalForAll and is used to iterate over the raw logs and unpacked data for ApprovalForAll events raised by the ERC721 contract.
|
|
type ERC721ApprovalForAllIterator struct {
|
|
Event *ERC721ApprovalForAll // 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 *ERC721ApprovalForAllIterator) 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(ERC721ApprovalForAll)
|
|
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(ERC721ApprovalForAll)
|
|
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 *ERC721ApprovalForAllIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ERC721ApprovalForAllIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ERC721ApprovalForAll represents a ApprovalForAll event raised by the ERC721 contract.
|
|
type ERC721ApprovalForAll struct {
|
|
Owner common.Address
|
|
Operator common.Address
|
|
Approved bool
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterApprovalForAll is a free log retrieval operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_ERC721 *ERC721Filterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*ERC721ApprovalForAllIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721.contract.FilterLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721ApprovalForAllIterator{contract: _ERC721.contract, event: "ApprovalForAll", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchApprovalForAll is a free log subscription operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_ERC721 *ERC721Filterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *ERC721ApprovalForAll, owner []common.Address, operator []common.Address) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721.contract.WatchLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
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(ERC721ApprovalForAll)
|
|
if err := _ERC721.contract.UnpackLog(event, "ApprovalForAll", 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
|
|
}
|
|
|
|
// ParseApprovalForAll is a log parse operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_ERC721 *ERC721Filterer) ParseApprovalForAll(log types.Log) (*ERC721ApprovalForAll, error) {
|
|
event := new(ERC721ApprovalForAll)
|
|
if err := _ERC721.contract.UnpackLog(event, "ApprovalForAll", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ERC721TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ERC721 contract.
|
|
type ERC721TransferIterator struct {
|
|
Event *ERC721Transfer // 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 *ERC721TransferIterator) 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(ERC721Transfer)
|
|
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(ERC721Transfer)
|
|
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 *ERC721TransferIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ERC721TransferIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ERC721Transfer represents a Transfer event raised by the ERC721 contract.
|
|
type ERC721Transfer struct {
|
|
From common.Address
|
|
To common.Address
|
|
TokenId *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 indexed tokenId)
|
|
func (_ERC721 *ERC721Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, tokenId []*big.Int) (*ERC721TransferIterator, error) {
|
|
|
|
var fromRule []interface{}
|
|
for _, fromItem := range from {
|
|
fromRule = append(fromRule, fromItem)
|
|
}
|
|
var toRule []interface{}
|
|
for _, toItem := range to {
|
|
toRule = append(toRule, toItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721.contract.FilterLogs(opts, "Transfer", fromRule, toRule, tokenIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721TransferIterator{contract: _ERC721.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 indexed tokenId)
|
|
func (_ERC721 *ERC721Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC721Transfer, from []common.Address, to []common.Address, tokenId []*big.Int) (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)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721.contract.WatchLogs(opts, "Transfer", fromRule, toRule, tokenIdRule)
|
|
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(ERC721Transfer)
|
|
if err := _ERC721.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 indexed tokenId)
|
|
func (_ERC721 *ERC721Filterer) ParseTransfer(log types.Log) (*ERC721Transfer, error) {
|
|
event := new(ERC721Transfer)
|
|
if err := _ERC721.contract.UnpackLog(event, "Transfer", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ERC721EnumerableABI is the input ABI used to generate the binding from.
|
|
const ERC721EnumerableABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"getApproved\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"tokenOfOwnerByIndex\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"tokenByIndex\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"ownerOf\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"},{\"name\":\"_data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"approved\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"}]"
|
|
|
|
// ERC721EnumerableFuncSigs maps the 4-byte function signature to its string representation.
|
|
var ERC721EnumerableFuncSigs = map[string]string{
|
|
"095ea7b3": "approve(address,uint256)",
|
|
"70a08231": "balanceOf(address)",
|
|
"081812fc": "getApproved(uint256)",
|
|
"e985e9c5": "isApprovedForAll(address,address)",
|
|
"6352211e": "ownerOf(uint256)",
|
|
"42842e0e": "safeTransferFrom(address,address,uint256)",
|
|
"b88d4fde": "safeTransferFrom(address,address,uint256,bytes)",
|
|
"a22cb465": "setApprovalForAll(address,bool)",
|
|
"01ffc9a7": "supportsInterface(bytes4)",
|
|
"4f6ccce7": "tokenByIndex(uint256)",
|
|
"2f745c59": "tokenOfOwnerByIndex(address,uint256)",
|
|
"18160ddd": "totalSupply()",
|
|
"23b872dd": "transferFrom(address,address,uint256)",
|
|
}
|
|
|
|
// ERC721Enumerable is an auto generated Go binding around an Ethereum contract.
|
|
type ERC721Enumerable struct {
|
|
ERC721EnumerableCaller // Read-only binding to the contract
|
|
ERC721EnumerableTransactor // Write-only binding to the contract
|
|
ERC721EnumerableFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// ERC721EnumerableCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type ERC721EnumerableCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ERC721EnumerableTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type ERC721EnumerableTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ERC721EnumerableFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type ERC721EnumerableFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ERC721EnumerableSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type ERC721EnumerableSession struct {
|
|
Contract *ERC721Enumerable // 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
|
|
}
|
|
|
|
// ERC721EnumerableCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type ERC721EnumerableCallerSession struct {
|
|
Contract *ERC721EnumerableCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// ERC721EnumerableTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type ERC721EnumerableTransactorSession struct {
|
|
Contract *ERC721EnumerableTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// ERC721EnumerableRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type ERC721EnumerableRaw struct {
|
|
Contract *ERC721Enumerable // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// ERC721EnumerableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type ERC721EnumerableCallerRaw struct {
|
|
Contract *ERC721EnumerableCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// ERC721EnumerableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type ERC721EnumerableTransactorRaw struct {
|
|
Contract *ERC721EnumerableTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewERC721Enumerable creates a new instance of ERC721Enumerable, bound to a specific deployed contract.
|
|
func NewERC721Enumerable(address common.Address, backend bind.ContractBackend) (*ERC721Enumerable, error) {
|
|
contract, err := bindERC721Enumerable(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721Enumerable{ERC721EnumerableCaller: ERC721EnumerableCaller{contract: contract}, ERC721EnumerableTransactor: ERC721EnumerableTransactor{contract: contract}, ERC721EnumerableFilterer: ERC721EnumerableFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewERC721EnumerableCaller creates a new read-only instance of ERC721Enumerable, bound to a specific deployed contract.
|
|
func NewERC721EnumerableCaller(address common.Address, caller bind.ContractCaller) (*ERC721EnumerableCaller, error) {
|
|
contract, err := bindERC721Enumerable(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721EnumerableCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewERC721EnumerableTransactor creates a new write-only instance of ERC721Enumerable, bound to a specific deployed contract.
|
|
func NewERC721EnumerableTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC721EnumerableTransactor, error) {
|
|
contract, err := bindERC721Enumerable(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721EnumerableTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewERC721EnumerableFilterer creates a new log filterer instance of ERC721Enumerable, bound to a specific deployed contract.
|
|
func NewERC721EnumerableFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC721EnumerableFilterer, error) {
|
|
contract, err := bindERC721Enumerable(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721EnumerableFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindERC721Enumerable binds a generic wrapper to an already deployed contract.
|
|
func bindERC721Enumerable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(ERC721EnumerableABI))
|
|
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 (_ERC721Enumerable *ERC721EnumerableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ERC721Enumerable.Contract.ERC721EnumerableCaller.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 (_ERC721Enumerable *ERC721EnumerableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ERC721Enumerable.Contract.ERC721EnumerableTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ERC721Enumerable *ERC721EnumerableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ERC721Enumerable.Contract.ERC721EnumerableTransactor.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 (_ERC721Enumerable *ERC721EnumerableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ERC721Enumerable.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 (_ERC721Enumerable *ERC721EnumerableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ERC721Enumerable.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ERC721Enumerable *ERC721EnumerableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ERC721Enumerable.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address owner) view returns(uint256)
|
|
func (_ERC721Enumerable *ERC721EnumerableCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _ERC721Enumerable.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 (_ERC721Enumerable *ERC721EnumerableSession) BalanceOf(owner common.Address) (*big.Int, error) {
|
|
return _ERC721Enumerable.Contract.BalanceOf(&_ERC721Enumerable.CallOpts, owner)
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address owner) view returns(uint256)
|
|
func (_ERC721Enumerable *ERC721EnumerableCallerSession) BalanceOf(owner common.Address) (*big.Int, error) {
|
|
return _ERC721Enumerable.Contract.BalanceOf(&_ERC721Enumerable.CallOpts, owner)
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address)
|
|
func (_ERC721Enumerable *ERC721EnumerableCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _ERC721Enumerable.contract.Call(opts, &out, "getApproved", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address)
|
|
func (_ERC721Enumerable *ERC721EnumerableSession) GetApproved(tokenId *big.Int) (common.Address, error) {
|
|
return _ERC721Enumerable.Contract.GetApproved(&_ERC721Enumerable.CallOpts, tokenId)
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address)
|
|
func (_ERC721Enumerable *ERC721EnumerableCallerSession) GetApproved(tokenId *big.Int) (common.Address, error) {
|
|
return _ERC721Enumerable.Contract.GetApproved(&_ERC721Enumerable.CallOpts, tokenId)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_ERC721Enumerable *ERC721EnumerableCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error) {
|
|
var out []interface{}
|
|
err := _ERC721Enumerable.contract.Call(opts, &out, "isApprovedForAll", owner, operator)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_ERC721Enumerable *ERC721EnumerableSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _ERC721Enumerable.Contract.IsApprovedForAll(&_ERC721Enumerable.CallOpts, owner, operator)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_ERC721Enumerable *ERC721EnumerableCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _ERC721Enumerable.Contract.IsApprovedForAll(&_ERC721Enumerable.CallOpts, owner, operator)
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address)
|
|
func (_ERC721Enumerable *ERC721EnumerableCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _ERC721Enumerable.contract.Call(opts, &out, "ownerOf", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address)
|
|
func (_ERC721Enumerable *ERC721EnumerableSession) OwnerOf(tokenId *big.Int) (common.Address, error) {
|
|
return _ERC721Enumerable.Contract.OwnerOf(&_ERC721Enumerable.CallOpts, tokenId)
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address)
|
|
func (_ERC721Enumerable *ERC721EnumerableCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error) {
|
|
return _ERC721Enumerable.Contract.OwnerOf(&_ERC721Enumerable.CallOpts, tokenId)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_ERC721Enumerable *ERC721EnumerableCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _ERC721Enumerable.contract.Call(opts, &out, "supportsInterface", interfaceId)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_ERC721Enumerable *ERC721EnumerableSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _ERC721Enumerable.Contract.SupportsInterface(&_ERC721Enumerable.CallOpts, interfaceId)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_ERC721Enumerable *ERC721EnumerableCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _ERC721Enumerable.Contract.SupportsInterface(&_ERC721Enumerable.CallOpts, interfaceId)
|
|
}
|
|
|
|
// TokenByIndex is a free data retrieval call binding the contract method 0x4f6ccce7.
|
|
//
|
|
// Solidity: function tokenByIndex(uint256 index) view returns(uint256)
|
|
func (_ERC721Enumerable *ERC721EnumerableCaller) TokenByIndex(opts *bind.CallOpts, index *big.Int) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _ERC721Enumerable.contract.Call(opts, &out, "tokenByIndex", index)
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// TokenByIndex is a free data retrieval call binding the contract method 0x4f6ccce7.
|
|
//
|
|
// Solidity: function tokenByIndex(uint256 index) view returns(uint256)
|
|
func (_ERC721Enumerable *ERC721EnumerableSession) TokenByIndex(index *big.Int) (*big.Int, error) {
|
|
return _ERC721Enumerable.Contract.TokenByIndex(&_ERC721Enumerable.CallOpts, index)
|
|
}
|
|
|
|
// TokenByIndex is a free data retrieval call binding the contract method 0x4f6ccce7.
|
|
//
|
|
// Solidity: function tokenByIndex(uint256 index) view returns(uint256)
|
|
func (_ERC721Enumerable *ERC721EnumerableCallerSession) TokenByIndex(index *big.Int) (*big.Int, error) {
|
|
return _ERC721Enumerable.Contract.TokenByIndex(&_ERC721Enumerable.CallOpts, index)
|
|
}
|
|
|
|
// TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59.
|
|
//
|
|
// Solidity: function tokenOfOwnerByIndex(address owner, uint256 index) view returns(uint256)
|
|
func (_ERC721Enumerable *ERC721EnumerableCaller) TokenOfOwnerByIndex(opts *bind.CallOpts, owner common.Address, index *big.Int) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _ERC721Enumerable.contract.Call(opts, &out, "tokenOfOwnerByIndex", owner, index)
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59.
|
|
//
|
|
// Solidity: function tokenOfOwnerByIndex(address owner, uint256 index) view returns(uint256)
|
|
func (_ERC721Enumerable *ERC721EnumerableSession) TokenOfOwnerByIndex(owner common.Address, index *big.Int) (*big.Int, error) {
|
|
return _ERC721Enumerable.Contract.TokenOfOwnerByIndex(&_ERC721Enumerable.CallOpts, owner, index)
|
|
}
|
|
|
|
// TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59.
|
|
//
|
|
// Solidity: function tokenOfOwnerByIndex(address owner, uint256 index) view returns(uint256)
|
|
func (_ERC721Enumerable *ERC721EnumerableCallerSession) TokenOfOwnerByIndex(owner common.Address, index *big.Int) (*big.Int, error) {
|
|
return _ERC721Enumerable.Contract.TokenOfOwnerByIndex(&_ERC721Enumerable.CallOpts, owner, index)
|
|
}
|
|
|
|
// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
|
|
//
|
|
// Solidity: function totalSupply() view returns(uint256)
|
|
func (_ERC721Enumerable *ERC721EnumerableCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _ERC721Enumerable.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 (_ERC721Enumerable *ERC721EnumerableSession) TotalSupply() (*big.Int, error) {
|
|
return _ERC721Enumerable.Contract.TotalSupply(&_ERC721Enumerable.CallOpts)
|
|
}
|
|
|
|
// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
|
|
//
|
|
// Solidity: function totalSupply() view returns(uint256)
|
|
func (_ERC721Enumerable *ERC721EnumerableCallerSession) TotalSupply() (*big.Int, error) {
|
|
return _ERC721Enumerable.Contract.TotalSupply(&_ERC721Enumerable.CallOpts)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_ERC721Enumerable *ERC721EnumerableTransactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Enumerable.contract.Transact(opts, "approve", to, tokenId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_ERC721Enumerable *ERC721EnumerableSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Enumerable.Contract.Approve(&_ERC721Enumerable.TransactOpts, to, tokenId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_ERC721Enumerable *ERC721EnumerableTransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Enumerable.Contract.Approve(&_ERC721Enumerable.TransactOpts, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721Enumerable *ERC721EnumerableTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Enumerable.contract.Transact(opts, "safeTransferFrom", from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721Enumerable *ERC721EnumerableSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Enumerable.Contract.SafeTransferFrom(&_ERC721Enumerable.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721Enumerable *ERC721EnumerableTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Enumerable.Contract.SafeTransferFrom(&_ERC721Enumerable.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes _data) returns()
|
|
func (_ERC721Enumerable *ERC721EnumerableTransactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error) {
|
|
return _ERC721Enumerable.contract.Transact(opts, "safeTransferFrom0", from, to, tokenId, _data)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes _data) returns()
|
|
func (_ERC721Enumerable *ERC721EnumerableSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error) {
|
|
return _ERC721Enumerable.Contract.SafeTransferFrom0(&_ERC721Enumerable.TransactOpts, from, to, tokenId, _data)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes _data) returns()
|
|
func (_ERC721Enumerable *ERC721EnumerableTransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error) {
|
|
return _ERC721Enumerable.Contract.SafeTransferFrom0(&_ERC721Enumerable.TransactOpts, from, to, tokenId, _data)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address to, bool approved) returns()
|
|
func (_ERC721Enumerable *ERC721EnumerableTransactor) SetApprovalForAll(opts *bind.TransactOpts, to common.Address, approved bool) (*types.Transaction, error) {
|
|
return _ERC721Enumerable.contract.Transact(opts, "setApprovalForAll", to, approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address to, bool approved) returns()
|
|
func (_ERC721Enumerable *ERC721EnumerableSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error) {
|
|
return _ERC721Enumerable.Contract.SetApprovalForAll(&_ERC721Enumerable.TransactOpts, to, approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address to, bool approved) returns()
|
|
func (_ERC721Enumerable *ERC721EnumerableTransactorSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error) {
|
|
return _ERC721Enumerable.Contract.SetApprovalForAll(&_ERC721Enumerable.TransactOpts, to, approved)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721Enumerable *ERC721EnumerableTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Enumerable.contract.Transact(opts, "transferFrom", from, to, tokenId)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721Enumerable *ERC721EnumerableSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Enumerable.Contract.TransferFrom(&_ERC721Enumerable.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721Enumerable *ERC721EnumerableTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Enumerable.Contract.TransferFrom(&_ERC721Enumerable.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// ERC721EnumerableApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ERC721Enumerable contract.
|
|
type ERC721EnumerableApprovalIterator struct {
|
|
Event *ERC721EnumerableApproval // 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 *ERC721EnumerableApprovalIterator) 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(ERC721EnumerableApproval)
|
|
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(ERC721EnumerableApproval)
|
|
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 *ERC721EnumerableApprovalIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ERC721EnumerableApprovalIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ERC721EnumerableApproval represents a Approval event raised by the ERC721Enumerable contract.
|
|
type ERC721EnumerableApproval struct {
|
|
Owner common.Address
|
|
Approved common.Address
|
|
TokenId *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 approved, uint256 indexed tokenId)
|
|
func (_ERC721Enumerable *ERC721EnumerableFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, tokenId []*big.Int) (*ERC721EnumerableApprovalIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var approvedRule []interface{}
|
|
for _, approvedItem := range approved {
|
|
approvedRule = append(approvedRule, approvedItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721Enumerable.contract.FilterLogs(opts, "Approval", ownerRule, approvedRule, tokenIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721EnumerableApprovalIterator{contract: _ERC721Enumerable.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 approved, uint256 indexed tokenId)
|
|
func (_ERC721Enumerable *ERC721EnumerableFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC721EnumerableApproval, owner []common.Address, approved []common.Address, tokenId []*big.Int) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var approvedRule []interface{}
|
|
for _, approvedItem := range approved {
|
|
approvedRule = append(approvedRule, approvedItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721Enumerable.contract.WatchLogs(opts, "Approval", ownerRule, approvedRule, tokenIdRule)
|
|
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(ERC721EnumerableApproval)
|
|
if err := _ERC721Enumerable.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 approved, uint256 indexed tokenId)
|
|
func (_ERC721Enumerable *ERC721EnumerableFilterer) ParseApproval(log types.Log) (*ERC721EnumerableApproval, error) {
|
|
event := new(ERC721EnumerableApproval)
|
|
if err := _ERC721Enumerable.contract.UnpackLog(event, "Approval", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ERC721EnumerableApprovalForAllIterator is returned from FilterApprovalForAll and is used to iterate over the raw logs and unpacked data for ApprovalForAll events raised by the ERC721Enumerable contract.
|
|
type ERC721EnumerableApprovalForAllIterator struct {
|
|
Event *ERC721EnumerableApprovalForAll // 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 *ERC721EnumerableApprovalForAllIterator) 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(ERC721EnumerableApprovalForAll)
|
|
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(ERC721EnumerableApprovalForAll)
|
|
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 *ERC721EnumerableApprovalForAllIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ERC721EnumerableApprovalForAllIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ERC721EnumerableApprovalForAll represents a ApprovalForAll event raised by the ERC721Enumerable contract.
|
|
type ERC721EnumerableApprovalForAll struct {
|
|
Owner common.Address
|
|
Operator common.Address
|
|
Approved bool
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterApprovalForAll is a free log retrieval operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_ERC721Enumerable *ERC721EnumerableFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*ERC721EnumerableApprovalForAllIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721Enumerable.contract.FilterLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721EnumerableApprovalForAllIterator{contract: _ERC721Enumerable.contract, event: "ApprovalForAll", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchApprovalForAll is a free log subscription operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_ERC721Enumerable *ERC721EnumerableFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *ERC721EnumerableApprovalForAll, owner []common.Address, operator []common.Address) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721Enumerable.contract.WatchLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
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(ERC721EnumerableApprovalForAll)
|
|
if err := _ERC721Enumerable.contract.UnpackLog(event, "ApprovalForAll", 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
|
|
}
|
|
|
|
// ParseApprovalForAll is a log parse operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_ERC721Enumerable *ERC721EnumerableFilterer) ParseApprovalForAll(log types.Log) (*ERC721EnumerableApprovalForAll, error) {
|
|
event := new(ERC721EnumerableApprovalForAll)
|
|
if err := _ERC721Enumerable.contract.UnpackLog(event, "ApprovalForAll", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ERC721EnumerableTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ERC721Enumerable contract.
|
|
type ERC721EnumerableTransferIterator struct {
|
|
Event *ERC721EnumerableTransfer // 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 *ERC721EnumerableTransferIterator) 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(ERC721EnumerableTransfer)
|
|
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(ERC721EnumerableTransfer)
|
|
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 *ERC721EnumerableTransferIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ERC721EnumerableTransferIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ERC721EnumerableTransfer represents a Transfer event raised by the ERC721Enumerable contract.
|
|
type ERC721EnumerableTransfer struct {
|
|
From common.Address
|
|
To common.Address
|
|
TokenId *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 indexed tokenId)
|
|
func (_ERC721Enumerable *ERC721EnumerableFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, tokenId []*big.Int) (*ERC721EnumerableTransferIterator, error) {
|
|
|
|
var fromRule []interface{}
|
|
for _, fromItem := range from {
|
|
fromRule = append(fromRule, fromItem)
|
|
}
|
|
var toRule []interface{}
|
|
for _, toItem := range to {
|
|
toRule = append(toRule, toItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721Enumerable.contract.FilterLogs(opts, "Transfer", fromRule, toRule, tokenIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721EnumerableTransferIterator{contract: _ERC721Enumerable.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 indexed tokenId)
|
|
func (_ERC721Enumerable *ERC721EnumerableFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC721EnumerableTransfer, from []common.Address, to []common.Address, tokenId []*big.Int) (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)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721Enumerable.contract.WatchLogs(opts, "Transfer", fromRule, toRule, tokenIdRule)
|
|
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(ERC721EnumerableTransfer)
|
|
if err := _ERC721Enumerable.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 indexed tokenId)
|
|
func (_ERC721Enumerable *ERC721EnumerableFilterer) ParseTransfer(log types.Log) (*ERC721EnumerableTransfer, error) {
|
|
event := new(ERC721EnumerableTransfer)
|
|
if err := _ERC721Enumerable.contract.UnpackLog(event, "Transfer", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ERC721FullABI is the input ABI used to generate the binding from.
|
|
const ERC721FullABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"getApproved\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"tokenOfOwnerByIndex\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"tokenByIndex\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"ownerOf\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"},{\"name\":\"_data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"tokenURI\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"approved\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"}]"
|
|
|
|
// ERC721FullFuncSigs maps the 4-byte function signature to its string representation.
|
|
var ERC721FullFuncSigs = map[string]string{
|
|
"095ea7b3": "approve(address,uint256)",
|
|
"70a08231": "balanceOf(address)",
|
|
"081812fc": "getApproved(uint256)",
|
|
"e985e9c5": "isApprovedForAll(address,address)",
|
|
"06fdde03": "name()",
|
|
"6352211e": "ownerOf(uint256)",
|
|
"42842e0e": "safeTransferFrom(address,address,uint256)",
|
|
"b88d4fde": "safeTransferFrom(address,address,uint256,bytes)",
|
|
"a22cb465": "setApprovalForAll(address,bool)",
|
|
"01ffc9a7": "supportsInterface(bytes4)",
|
|
"95d89b41": "symbol()",
|
|
"4f6ccce7": "tokenByIndex(uint256)",
|
|
"2f745c59": "tokenOfOwnerByIndex(address,uint256)",
|
|
"c87b56dd": "tokenURI(uint256)",
|
|
"18160ddd": "totalSupply()",
|
|
"23b872dd": "transferFrom(address,address,uint256)",
|
|
}
|
|
|
|
// ERC721Full is an auto generated Go binding around an Ethereum contract.
|
|
type ERC721Full struct {
|
|
ERC721FullCaller // Read-only binding to the contract
|
|
ERC721FullTransactor // Write-only binding to the contract
|
|
ERC721FullFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// ERC721FullCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type ERC721FullCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ERC721FullTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type ERC721FullTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ERC721FullFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type ERC721FullFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ERC721FullSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type ERC721FullSession struct {
|
|
Contract *ERC721Full // 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
|
|
}
|
|
|
|
// ERC721FullCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type ERC721FullCallerSession struct {
|
|
Contract *ERC721FullCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// ERC721FullTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type ERC721FullTransactorSession struct {
|
|
Contract *ERC721FullTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// ERC721FullRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type ERC721FullRaw struct {
|
|
Contract *ERC721Full // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// ERC721FullCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type ERC721FullCallerRaw struct {
|
|
Contract *ERC721FullCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// ERC721FullTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type ERC721FullTransactorRaw struct {
|
|
Contract *ERC721FullTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewERC721Full creates a new instance of ERC721Full, bound to a specific deployed contract.
|
|
func NewERC721Full(address common.Address, backend bind.ContractBackend) (*ERC721Full, error) {
|
|
contract, err := bindERC721Full(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721Full{ERC721FullCaller: ERC721FullCaller{contract: contract}, ERC721FullTransactor: ERC721FullTransactor{contract: contract}, ERC721FullFilterer: ERC721FullFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewERC721FullCaller creates a new read-only instance of ERC721Full, bound to a specific deployed contract.
|
|
func NewERC721FullCaller(address common.Address, caller bind.ContractCaller) (*ERC721FullCaller, error) {
|
|
contract, err := bindERC721Full(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721FullCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewERC721FullTransactor creates a new write-only instance of ERC721Full, bound to a specific deployed contract.
|
|
func NewERC721FullTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC721FullTransactor, error) {
|
|
contract, err := bindERC721Full(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721FullTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewERC721FullFilterer creates a new log filterer instance of ERC721Full, bound to a specific deployed contract.
|
|
func NewERC721FullFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC721FullFilterer, error) {
|
|
contract, err := bindERC721Full(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721FullFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindERC721Full binds a generic wrapper to an already deployed contract.
|
|
func bindERC721Full(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(ERC721FullABI))
|
|
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 (_ERC721Full *ERC721FullRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ERC721Full.Contract.ERC721FullCaller.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 (_ERC721Full *ERC721FullRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ERC721Full.Contract.ERC721FullTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ERC721Full *ERC721FullRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ERC721Full.Contract.ERC721FullTransactor.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 (_ERC721Full *ERC721FullCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ERC721Full.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 (_ERC721Full *ERC721FullTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ERC721Full.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ERC721Full *ERC721FullTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ERC721Full.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address owner) view returns(uint256)
|
|
func (_ERC721Full *ERC721FullCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _ERC721Full.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 (_ERC721Full *ERC721FullSession) BalanceOf(owner common.Address) (*big.Int, error) {
|
|
return _ERC721Full.Contract.BalanceOf(&_ERC721Full.CallOpts, owner)
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address owner) view returns(uint256)
|
|
func (_ERC721Full *ERC721FullCallerSession) BalanceOf(owner common.Address) (*big.Int, error) {
|
|
return _ERC721Full.Contract.BalanceOf(&_ERC721Full.CallOpts, owner)
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address)
|
|
func (_ERC721Full *ERC721FullCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _ERC721Full.contract.Call(opts, &out, "getApproved", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address)
|
|
func (_ERC721Full *ERC721FullSession) GetApproved(tokenId *big.Int) (common.Address, error) {
|
|
return _ERC721Full.Contract.GetApproved(&_ERC721Full.CallOpts, tokenId)
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address)
|
|
func (_ERC721Full *ERC721FullCallerSession) GetApproved(tokenId *big.Int) (common.Address, error) {
|
|
return _ERC721Full.Contract.GetApproved(&_ERC721Full.CallOpts, tokenId)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_ERC721Full *ERC721FullCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error) {
|
|
var out []interface{}
|
|
err := _ERC721Full.contract.Call(opts, &out, "isApprovedForAll", owner, operator)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_ERC721Full *ERC721FullSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _ERC721Full.Contract.IsApprovedForAll(&_ERC721Full.CallOpts, owner, operator)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_ERC721Full *ERC721FullCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _ERC721Full.Contract.IsApprovedForAll(&_ERC721Full.CallOpts, owner, operator)
|
|
}
|
|
|
|
// Name is a free data retrieval call binding the contract method 0x06fdde03.
|
|
//
|
|
// Solidity: function name() view returns(string)
|
|
func (_ERC721Full *ERC721FullCaller) Name(opts *bind.CallOpts) (string, error) {
|
|
var out []interface{}
|
|
err := _ERC721Full.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 (_ERC721Full *ERC721FullSession) Name() (string, error) {
|
|
return _ERC721Full.Contract.Name(&_ERC721Full.CallOpts)
|
|
}
|
|
|
|
// Name is a free data retrieval call binding the contract method 0x06fdde03.
|
|
//
|
|
// Solidity: function name() view returns(string)
|
|
func (_ERC721Full *ERC721FullCallerSession) Name() (string, error) {
|
|
return _ERC721Full.Contract.Name(&_ERC721Full.CallOpts)
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address)
|
|
func (_ERC721Full *ERC721FullCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _ERC721Full.contract.Call(opts, &out, "ownerOf", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address)
|
|
func (_ERC721Full *ERC721FullSession) OwnerOf(tokenId *big.Int) (common.Address, error) {
|
|
return _ERC721Full.Contract.OwnerOf(&_ERC721Full.CallOpts, tokenId)
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address)
|
|
func (_ERC721Full *ERC721FullCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error) {
|
|
return _ERC721Full.Contract.OwnerOf(&_ERC721Full.CallOpts, tokenId)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_ERC721Full *ERC721FullCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _ERC721Full.contract.Call(opts, &out, "supportsInterface", interfaceId)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_ERC721Full *ERC721FullSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _ERC721Full.Contract.SupportsInterface(&_ERC721Full.CallOpts, interfaceId)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_ERC721Full *ERC721FullCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _ERC721Full.Contract.SupportsInterface(&_ERC721Full.CallOpts, interfaceId)
|
|
}
|
|
|
|
// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
|
|
//
|
|
// Solidity: function symbol() view returns(string)
|
|
func (_ERC721Full *ERC721FullCaller) Symbol(opts *bind.CallOpts) (string, error) {
|
|
var out []interface{}
|
|
err := _ERC721Full.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 (_ERC721Full *ERC721FullSession) Symbol() (string, error) {
|
|
return _ERC721Full.Contract.Symbol(&_ERC721Full.CallOpts)
|
|
}
|
|
|
|
// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
|
|
//
|
|
// Solidity: function symbol() view returns(string)
|
|
func (_ERC721Full *ERC721FullCallerSession) Symbol() (string, error) {
|
|
return _ERC721Full.Contract.Symbol(&_ERC721Full.CallOpts)
|
|
}
|
|
|
|
// TokenByIndex is a free data retrieval call binding the contract method 0x4f6ccce7.
|
|
//
|
|
// Solidity: function tokenByIndex(uint256 index) view returns(uint256)
|
|
func (_ERC721Full *ERC721FullCaller) TokenByIndex(opts *bind.CallOpts, index *big.Int) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _ERC721Full.contract.Call(opts, &out, "tokenByIndex", index)
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// TokenByIndex is a free data retrieval call binding the contract method 0x4f6ccce7.
|
|
//
|
|
// Solidity: function tokenByIndex(uint256 index) view returns(uint256)
|
|
func (_ERC721Full *ERC721FullSession) TokenByIndex(index *big.Int) (*big.Int, error) {
|
|
return _ERC721Full.Contract.TokenByIndex(&_ERC721Full.CallOpts, index)
|
|
}
|
|
|
|
// TokenByIndex is a free data retrieval call binding the contract method 0x4f6ccce7.
|
|
//
|
|
// Solidity: function tokenByIndex(uint256 index) view returns(uint256)
|
|
func (_ERC721Full *ERC721FullCallerSession) TokenByIndex(index *big.Int) (*big.Int, error) {
|
|
return _ERC721Full.Contract.TokenByIndex(&_ERC721Full.CallOpts, index)
|
|
}
|
|
|
|
// TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59.
|
|
//
|
|
// Solidity: function tokenOfOwnerByIndex(address owner, uint256 index) view returns(uint256)
|
|
func (_ERC721Full *ERC721FullCaller) TokenOfOwnerByIndex(opts *bind.CallOpts, owner common.Address, index *big.Int) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _ERC721Full.contract.Call(opts, &out, "tokenOfOwnerByIndex", owner, index)
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59.
|
|
//
|
|
// Solidity: function tokenOfOwnerByIndex(address owner, uint256 index) view returns(uint256)
|
|
func (_ERC721Full *ERC721FullSession) TokenOfOwnerByIndex(owner common.Address, index *big.Int) (*big.Int, error) {
|
|
return _ERC721Full.Contract.TokenOfOwnerByIndex(&_ERC721Full.CallOpts, owner, index)
|
|
}
|
|
|
|
// TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59.
|
|
//
|
|
// Solidity: function tokenOfOwnerByIndex(address owner, uint256 index) view returns(uint256)
|
|
func (_ERC721Full *ERC721FullCallerSession) TokenOfOwnerByIndex(owner common.Address, index *big.Int) (*big.Int, error) {
|
|
return _ERC721Full.Contract.TokenOfOwnerByIndex(&_ERC721Full.CallOpts, owner, index)
|
|
}
|
|
|
|
// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd.
|
|
//
|
|
// Solidity: function tokenURI(uint256 tokenId) view returns(string)
|
|
func (_ERC721Full *ERC721FullCaller) TokenURI(opts *bind.CallOpts, tokenId *big.Int) (string, error) {
|
|
var out []interface{}
|
|
err := _ERC721Full.contract.Call(opts, &out, "tokenURI", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(string), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(string)).(*string)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd.
|
|
//
|
|
// Solidity: function tokenURI(uint256 tokenId) view returns(string)
|
|
func (_ERC721Full *ERC721FullSession) TokenURI(tokenId *big.Int) (string, error) {
|
|
return _ERC721Full.Contract.TokenURI(&_ERC721Full.CallOpts, tokenId)
|
|
}
|
|
|
|
// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd.
|
|
//
|
|
// Solidity: function tokenURI(uint256 tokenId) view returns(string)
|
|
func (_ERC721Full *ERC721FullCallerSession) TokenURI(tokenId *big.Int) (string, error) {
|
|
return _ERC721Full.Contract.TokenURI(&_ERC721Full.CallOpts, tokenId)
|
|
}
|
|
|
|
// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
|
|
//
|
|
// Solidity: function totalSupply() view returns(uint256)
|
|
func (_ERC721Full *ERC721FullCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _ERC721Full.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 (_ERC721Full *ERC721FullSession) TotalSupply() (*big.Int, error) {
|
|
return _ERC721Full.Contract.TotalSupply(&_ERC721Full.CallOpts)
|
|
}
|
|
|
|
// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
|
|
//
|
|
// Solidity: function totalSupply() view returns(uint256)
|
|
func (_ERC721Full *ERC721FullCallerSession) TotalSupply() (*big.Int, error) {
|
|
return _ERC721Full.Contract.TotalSupply(&_ERC721Full.CallOpts)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_ERC721Full *ERC721FullTransactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Full.contract.Transact(opts, "approve", to, tokenId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_ERC721Full *ERC721FullSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Full.Contract.Approve(&_ERC721Full.TransactOpts, to, tokenId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_ERC721Full *ERC721FullTransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Full.Contract.Approve(&_ERC721Full.TransactOpts, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721Full *ERC721FullTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Full.contract.Transact(opts, "safeTransferFrom", from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721Full *ERC721FullSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Full.Contract.SafeTransferFrom(&_ERC721Full.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721Full *ERC721FullTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Full.Contract.SafeTransferFrom(&_ERC721Full.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes _data) returns()
|
|
func (_ERC721Full *ERC721FullTransactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error) {
|
|
return _ERC721Full.contract.Transact(opts, "safeTransferFrom0", from, to, tokenId, _data)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes _data) returns()
|
|
func (_ERC721Full *ERC721FullSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error) {
|
|
return _ERC721Full.Contract.SafeTransferFrom0(&_ERC721Full.TransactOpts, from, to, tokenId, _data)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes _data) returns()
|
|
func (_ERC721Full *ERC721FullTransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error) {
|
|
return _ERC721Full.Contract.SafeTransferFrom0(&_ERC721Full.TransactOpts, from, to, tokenId, _data)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address to, bool approved) returns()
|
|
func (_ERC721Full *ERC721FullTransactor) SetApprovalForAll(opts *bind.TransactOpts, to common.Address, approved bool) (*types.Transaction, error) {
|
|
return _ERC721Full.contract.Transact(opts, "setApprovalForAll", to, approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address to, bool approved) returns()
|
|
func (_ERC721Full *ERC721FullSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error) {
|
|
return _ERC721Full.Contract.SetApprovalForAll(&_ERC721Full.TransactOpts, to, approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address to, bool approved) returns()
|
|
func (_ERC721Full *ERC721FullTransactorSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error) {
|
|
return _ERC721Full.Contract.SetApprovalForAll(&_ERC721Full.TransactOpts, to, approved)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721Full *ERC721FullTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Full.contract.Transact(opts, "transferFrom", from, to, tokenId)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721Full *ERC721FullSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Full.Contract.TransferFrom(&_ERC721Full.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721Full *ERC721FullTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Full.Contract.TransferFrom(&_ERC721Full.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// ERC721FullApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ERC721Full contract.
|
|
type ERC721FullApprovalIterator struct {
|
|
Event *ERC721FullApproval // 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 *ERC721FullApprovalIterator) 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(ERC721FullApproval)
|
|
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(ERC721FullApproval)
|
|
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 *ERC721FullApprovalIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ERC721FullApprovalIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ERC721FullApproval represents a Approval event raised by the ERC721Full contract.
|
|
type ERC721FullApproval struct {
|
|
Owner common.Address
|
|
Approved common.Address
|
|
TokenId *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 approved, uint256 indexed tokenId)
|
|
func (_ERC721Full *ERC721FullFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, tokenId []*big.Int) (*ERC721FullApprovalIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var approvedRule []interface{}
|
|
for _, approvedItem := range approved {
|
|
approvedRule = append(approvedRule, approvedItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721Full.contract.FilterLogs(opts, "Approval", ownerRule, approvedRule, tokenIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721FullApprovalIterator{contract: _ERC721Full.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 approved, uint256 indexed tokenId)
|
|
func (_ERC721Full *ERC721FullFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC721FullApproval, owner []common.Address, approved []common.Address, tokenId []*big.Int) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var approvedRule []interface{}
|
|
for _, approvedItem := range approved {
|
|
approvedRule = append(approvedRule, approvedItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721Full.contract.WatchLogs(opts, "Approval", ownerRule, approvedRule, tokenIdRule)
|
|
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(ERC721FullApproval)
|
|
if err := _ERC721Full.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 approved, uint256 indexed tokenId)
|
|
func (_ERC721Full *ERC721FullFilterer) ParseApproval(log types.Log) (*ERC721FullApproval, error) {
|
|
event := new(ERC721FullApproval)
|
|
if err := _ERC721Full.contract.UnpackLog(event, "Approval", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ERC721FullApprovalForAllIterator is returned from FilterApprovalForAll and is used to iterate over the raw logs and unpacked data for ApprovalForAll events raised by the ERC721Full contract.
|
|
type ERC721FullApprovalForAllIterator struct {
|
|
Event *ERC721FullApprovalForAll // 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 *ERC721FullApprovalForAllIterator) 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(ERC721FullApprovalForAll)
|
|
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(ERC721FullApprovalForAll)
|
|
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 *ERC721FullApprovalForAllIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ERC721FullApprovalForAllIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ERC721FullApprovalForAll represents a ApprovalForAll event raised by the ERC721Full contract.
|
|
type ERC721FullApprovalForAll struct {
|
|
Owner common.Address
|
|
Operator common.Address
|
|
Approved bool
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterApprovalForAll is a free log retrieval operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_ERC721Full *ERC721FullFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*ERC721FullApprovalForAllIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721Full.contract.FilterLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721FullApprovalForAllIterator{contract: _ERC721Full.contract, event: "ApprovalForAll", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchApprovalForAll is a free log subscription operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_ERC721Full *ERC721FullFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *ERC721FullApprovalForAll, owner []common.Address, operator []common.Address) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721Full.contract.WatchLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
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(ERC721FullApprovalForAll)
|
|
if err := _ERC721Full.contract.UnpackLog(event, "ApprovalForAll", 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
|
|
}
|
|
|
|
// ParseApprovalForAll is a log parse operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_ERC721Full *ERC721FullFilterer) ParseApprovalForAll(log types.Log) (*ERC721FullApprovalForAll, error) {
|
|
event := new(ERC721FullApprovalForAll)
|
|
if err := _ERC721Full.contract.UnpackLog(event, "ApprovalForAll", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ERC721FullTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ERC721Full contract.
|
|
type ERC721FullTransferIterator struct {
|
|
Event *ERC721FullTransfer // 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 *ERC721FullTransferIterator) 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(ERC721FullTransfer)
|
|
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(ERC721FullTransfer)
|
|
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 *ERC721FullTransferIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ERC721FullTransferIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ERC721FullTransfer represents a Transfer event raised by the ERC721Full contract.
|
|
type ERC721FullTransfer struct {
|
|
From common.Address
|
|
To common.Address
|
|
TokenId *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 indexed tokenId)
|
|
func (_ERC721Full *ERC721FullFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, tokenId []*big.Int) (*ERC721FullTransferIterator, error) {
|
|
|
|
var fromRule []interface{}
|
|
for _, fromItem := range from {
|
|
fromRule = append(fromRule, fromItem)
|
|
}
|
|
var toRule []interface{}
|
|
for _, toItem := range to {
|
|
toRule = append(toRule, toItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721Full.contract.FilterLogs(opts, "Transfer", fromRule, toRule, tokenIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721FullTransferIterator{contract: _ERC721Full.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 indexed tokenId)
|
|
func (_ERC721Full *ERC721FullFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC721FullTransfer, from []common.Address, to []common.Address, tokenId []*big.Int) (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)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721Full.contract.WatchLogs(opts, "Transfer", fromRule, toRule, tokenIdRule)
|
|
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(ERC721FullTransfer)
|
|
if err := _ERC721Full.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 indexed tokenId)
|
|
func (_ERC721Full *ERC721FullFilterer) ParseTransfer(log types.Log) (*ERC721FullTransfer, error) {
|
|
event := new(ERC721FullTransfer)
|
|
if err := _ERC721Full.contract.UnpackLog(event, "Transfer", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ERC721MetadataABI is the input ABI used to generate the binding from.
|
|
const ERC721MetadataABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"getApproved\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"ownerOf\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"},{\"name\":\"_data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"tokenURI\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"approved\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"}]"
|
|
|
|
// ERC721MetadataFuncSigs maps the 4-byte function signature to its string representation.
|
|
var ERC721MetadataFuncSigs = map[string]string{
|
|
"095ea7b3": "approve(address,uint256)",
|
|
"70a08231": "balanceOf(address)",
|
|
"081812fc": "getApproved(uint256)",
|
|
"e985e9c5": "isApprovedForAll(address,address)",
|
|
"06fdde03": "name()",
|
|
"6352211e": "ownerOf(uint256)",
|
|
"42842e0e": "safeTransferFrom(address,address,uint256)",
|
|
"b88d4fde": "safeTransferFrom(address,address,uint256,bytes)",
|
|
"a22cb465": "setApprovalForAll(address,bool)",
|
|
"01ffc9a7": "supportsInterface(bytes4)",
|
|
"95d89b41": "symbol()",
|
|
"c87b56dd": "tokenURI(uint256)",
|
|
"23b872dd": "transferFrom(address,address,uint256)",
|
|
}
|
|
|
|
// ERC721Metadata is an auto generated Go binding around an Ethereum contract.
|
|
type ERC721Metadata struct {
|
|
ERC721MetadataCaller // Read-only binding to the contract
|
|
ERC721MetadataTransactor // Write-only binding to the contract
|
|
ERC721MetadataFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// ERC721MetadataCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type ERC721MetadataCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ERC721MetadataTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type ERC721MetadataTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ERC721MetadataFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type ERC721MetadataFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ERC721MetadataSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type ERC721MetadataSession struct {
|
|
Contract *ERC721Metadata // 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
|
|
}
|
|
|
|
// ERC721MetadataCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type ERC721MetadataCallerSession struct {
|
|
Contract *ERC721MetadataCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// ERC721MetadataTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type ERC721MetadataTransactorSession struct {
|
|
Contract *ERC721MetadataTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// ERC721MetadataRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type ERC721MetadataRaw struct {
|
|
Contract *ERC721Metadata // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// ERC721MetadataCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type ERC721MetadataCallerRaw struct {
|
|
Contract *ERC721MetadataCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// ERC721MetadataTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type ERC721MetadataTransactorRaw struct {
|
|
Contract *ERC721MetadataTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewERC721Metadata creates a new instance of ERC721Metadata, bound to a specific deployed contract.
|
|
func NewERC721Metadata(address common.Address, backend bind.ContractBackend) (*ERC721Metadata, error) {
|
|
contract, err := bindERC721Metadata(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721Metadata{ERC721MetadataCaller: ERC721MetadataCaller{contract: contract}, ERC721MetadataTransactor: ERC721MetadataTransactor{contract: contract}, ERC721MetadataFilterer: ERC721MetadataFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewERC721MetadataCaller creates a new read-only instance of ERC721Metadata, bound to a specific deployed contract.
|
|
func NewERC721MetadataCaller(address common.Address, caller bind.ContractCaller) (*ERC721MetadataCaller, error) {
|
|
contract, err := bindERC721Metadata(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721MetadataCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewERC721MetadataTransactor creates a new write-only instance of ERC721Metadata, bound to a specific deployed contract.
|
|
func NewERC721MetadataTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC721MetadataTransactor, error) {
|
|
contract, err := bindERC721Metadata(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721MetadataTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewERC721MetadataFilterer creates a new log filterer instance of ERC721Metadata, bound to a specific deployed contract.
|
|
func NewERC721MetadataFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC721MetadataFilterer, error) {
|
|
contract, err := bindERC721Metadata(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721MetadataFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindERC721Metadata binds a generic wrapper to an already deployed contract.
|
|
func bindERC721Metadata(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(ERC721MetadataABI))
|
|
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 (_ERC721Metadata *ERC721MetadataRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ERC721Metadata.Contract.ERC721MetadataCaller.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 (_ERC721Metadata *ERC721MetadataRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ERC721Metadata.Contract.ERC721MetadataTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ERC721Metadata *ERC721MetadataRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ERC721Metadata.Contract.ERC721MetadataTransactor.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 (_ERC721Metadata *ERC721MetadataCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ERC721Metadata.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 (_ERC721Metadata *ERC721MetadataTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ERC721Metadata.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ERC721Metadata *ERC721MetadataTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ERC721Metadata.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address owner) view returns(uint256)
|
|
func (_ERC721Metadata *ERC721MetadataCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _ERC721Metadata.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 (_ERC721Metadata *ERC721MetadataSession) BalanceOf(owner common.Address) (*big.Int, error) {
|
|
return _ERC721Metadata.Contract.BalanceOf(&_ERC721Metadata.CallOpts, owner)
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address owner) view returns(uint256)
|
|
func (_ERC721Metadata *ERC721MetadataCallerSession) BalanceOf(owner common.Address) (*big.Int, error) {
|
|
return _ERC721Metadata.Contract.BalanceOf(&_ERC721Metadata.CallOpts, owner)
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address)
|
|
func (_ERC721Metadata *ERC721MetadataCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _ERC721Metadata.contract.Call(opts, &out, "getApproved", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address)
|
|
func (_ERC721Metadata *ERC721MetadataSession) GetApproved(tokenId *big.Int) (common.Address, error) {
|
|
return _ERC721Metadata.Contract.GetApproved(&_ERC721Metadata.CallOpts, tokenId)
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address)
|
|
func (_ERC721Metadata *ERC721MetadataCallerSession) GetApproved(tokenId *big.Int) (common.Address, error) {
|
|
return _ERC721Metadata.Contract.GetApproved(&_ERC721Metadata.CallOpts, tokenId)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_ERC721Metadata *ERC721MetadataCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error) {
|
|
var out []interface{}
|
|
err := _ERC721Metadata.contract.Call(opts, &out, "isApprovedForAll", owner, operator)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_ERC721Metadata *ERC721MetadataSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _ERC721Metadata.Contract.IsApprovedForAll(&_ERC721Metadata.CallOpts, owner, operator)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_ERC721Metadata *ERC721MetadataCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _ERC721Metadata.Contract.IsApprovedForAll(&_ERC721Metadata.CallOpts, owner, operator)
|
|
}
|
|
|
|
// Name is a free data retrieval call binding the contract method 0x06fdde03.
|
|
//
|
|
// Solidity: function name() view returns(string)
|
|
func (_ERC721Metadata *ERC721MetadataCaller) Name(opts *bind.CallOpts) (string, error) {
|
|
var out []interface{}
|
|
err := _ERC721Metadata.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 (_ERC721Metadata *ERC721MetadataSession) Name() (string, error) {
|
|
return _ERC721Metadata.Contract.Name(&_ERC721Metadata.CallOpts)
|
|
}
|
|
|
|
// Name is a free data retrieval call binding the contract method 0x06fdde03.
|
|
//
|
|
// Solidity: function name() view returns(string)
|
|
func (_ERC721Metadata *ERC721MetadataCallerSession) Name() (string, error) {
|
|
return _ERC721Metadata.Contract.Name(&_ERC721Metadata.CallOpts)
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address)
|
|
func (_ERC721Metadata *ERC721MetadataCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _ERC721Metadata.contract.Call(opts, &out, "ownerOf", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address)
|
|
func (_ERC721Metadata *ERC721MetadataSession) OwnerOf(tokenId *big.Int) (common.Address, error) {
|
|
return _ERC721Metadata.Contract.OwnerOf(&_ERC721Metadata.CallOpts, tokenId)
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address)
|
|
func (_ERC721Metadata *ERC721MetadataCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error) {
|
|
return _ERC721Metadata.Contract.OwnerOf(&_ERC721Metadata.CallOpts, tokenId)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_ERC721Metadata *ERC721MetadataCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _ERC721Metadata.contract.Call(opts, &out, "supportsInterface", interfaceId)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_ERC721Metadata *ERC721MetadataSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _ERC721Metadata.Contract.SupportsInterface(&_ERC721Metadata.CallOpts, interfaceId)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_ERC721Metadata *ERC721MetadataCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _ERC721Metadata.Contract.SupportsInterface(&_ERC721Metadata.CallOpts, interfaceId)
|
|
}
|
|
|
|
// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
|
|
//
|
|
// Solidity: function symbol() view returns(string)
|
|
func (_ERC721Metadata *ERC721MetadataCaller) Symbol(opts *bind.CallOpts) (string, error) {
|
|
var out []interface{}
|
|
err := _ERC721Metadata.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 (_ERC721Metadata *ERC721MetadataSession) Symbol() (string, error) {
|
|
return _ERC721Metadata.Contract.Symbol(&_ERC721Metadata.CallOpts)
|
|
}
|
|
|
|
// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
|
|
//
|
|
// Solidity: function symbol() view returns(string)
|
|
func (_ERC721Metadata *ERC721MetadataCallerSession) Symbol() (string, error) {
|
|
return _ERC721Metadata.Contract.Symbol(&_ERC721Metadata.CallOpts)
|
|
}
|
|
|
|
// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd.
|
|
//
|
|
// Solidity: function tokenURI(uint256 tokenId) view returns(string)
|
|
func (_ERC721Metadata *ERC721MetadataCaller) TokenURI(opts *bind.CallOpts, tokenId *big.Int) (string, error) {
|
|
var out []interface{}
|
|
err := _ERC721Metadata.contract.Call(opts, &out, "tokenURI", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(string), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(string)).(*string)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd.
|
|
//
|
|
// Solidity: function tokenURI(uint256 tokenId) view returns(string)
|
|
func (_ERC721Metadata *ERC721MetadataSession) TokenURI(tokenId *big.Int) (string, error) {
|
|
return _ERC721Metadata.Contract.TokenURI(&_ERC721Metadata.CallOpts, tokenId)
|
|
}
|
|
|
|
// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd.
|
|
//
|
|
// Solidity: function tokenURI(uint256 tokenId) view returns(string)
|
|
func (_ERC721Metadata *ERC721MetadataCallerSession) TokenURI(tokenId *big.Int) (string, error) {
|
|
return _ERC721Metadata.Contract.TokenURI(&_ERC721Metadata.CallOpts, tokenId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_ERC721Metadata *ERC721MetadataTransactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Metadata.contract.Transact(opts, "approve", to, tokenId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_ERC721Metadata *ERC721MetadataSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Metadata.Contract.Approve(&_ERC721Metadata.TransactOpts, to, tokenId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_ERC721Metadata *ERC721MetadataTransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Metadata.Contract.Approve(&_ERC721Metadata.TransactOpts, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721Metadata *ERC721MetadataTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Metadata.contract.Transact(opts, "safeTransferFrom", from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721Metadata *ERC721MetadataSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Metadata.Contract.SafeTransferFrom(&_ERC721Metadata.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721Metadata *ERC721MetadataTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Metadata.Contract.SafeTransferFrom(&_ERC721Metadata.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes _data) returns()
|
|
func (_ERC721Metadata *ERC721MetadataTransactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error) {
|
|
return _ERC721Metadata.contract.Transact(opts, "safeTransferFrom0", from, to, tokenId, _data)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes _data) returns()
|
|
func (_ERC721Metadata *ERC721MetadataSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error) {
|
|
return _ERC721Metadata.Contract.SafeTransferFrom0(&_ERC721Metadata.TransactOpts, from, to, tokenId, _data)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes _data) returns()
|
|
func (_ERC721Metadata *ERC721MetadataTransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error) {
|
|
return _ERC721Metadata.Contract.SafeTransferFrom0(&_ERC721Metadata.TransactOpts, from, to, tokenId, _data)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address to, bool approved) returns()
|
|
func (_ERC721Metadata *ERC721MetadataTransactor) SetApprovalForAll(opts *bind.TransactOpts, to common.Address, approved bool) (*types.Transaction, error) {
|
|
return _ERC721Metadata.contract.Transact(opts, "setApprovalForAll", to, approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address to, bool approved) returns()
|
|
func (_ERC721Metadata *ERC721MetadataSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error) {
|
|
return _ERC721Metadata.Contract.SetApprovalForAll(&_ERC721Metadata.TransactOpts, to, approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address to, bool approved) returns()
|
|
func (_ERC721Metadata *ERC721MetadataTransactorSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error) {
|
|
return _ERC721Metadata.Contract.SetApprovalForAll(&_ERC721Metadata.TransactOpts, to, approved)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721Metadata *ERC721MetadataTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Metadata.contract.Transact(opts, "transferFrom", from, to, tokenId)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721Metadata *ERC721MetadataSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Metadata.Contract.TransferFrom(&_ERC721Metadata.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_ERC721Metadata *ERC721MetadataTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _ERC721Metadata.Contract.TransferFrom(&_ERC721Metadata.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// ERC721MetadataApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ERC721Metadata contract.
|
|
type ERC721MetadataApprovalIterator struct {
|
|
Event *ERC721MetadataApproval // 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 *ERC721MetadataApprovalIterator) 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(ERC721MetadataApproval)
|
|
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(ERC721MetadataApproval)
|
|
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 *ERC721MetadataApprovalIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ERC721MetadataApprovalIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ERC721MetadataApproval represents a Approval event raised by the ERC721Metadata contract.
|
|
type ERC721MetadataApproval struct {
|
|
Owner common.Address
|
|
Approved common.Address
|
|
TokenId *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 approved, uint256 indexed tokenId)
|
|
func (_ERC721Metadata *ERC721MetadataFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, tokenId []*big.Int) (*ERC721MetadataApprovalIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var approvedRule []interface{}
|
|
for _, approvedItem := range approved {
|
|
approvedRule = append(approvedRule, approvedItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721Metadata.contract.FilterLogs(opts, "Approval", ownerRule, approvedRule, tokenIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721MetadataApprovalIterator{contract: _ERC721Metadata.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 approved, uint256 indexed tokenId)
|
|
func (_ERC721Metadata *ERC721MetadataFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC721MetadataApproval, owner []common.Address, approved []common.Address, tokenId []*big.Int) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var approvedRule []interface{}
|
|
for _, approvedItem := range approved {
|
|
approvedRule = append(approvedRule, approvedItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721Metadata.contract.WatchLogs(opts, "Approval", ownerRule, approvedRule, tokenIdRule)
|
|
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(ERC721MetadataApproval)
|
|
if err := _ERC721Metadata.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 approved, uint256 indexed tokenId)
|
|
func (_ERC721Metadata *ERC721MetadataFilterer) ParseApproval(log types.Log) (*ERC721MetadataApproval, error) {
|
|
event := new(ERC721MetadataApproval)
|
|
if err := _ERC721Metadata.contract.UnpackLog(event, "Approval", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ERC721MetadataApprovalForAllIterator is returned from FilterApprovalForAll and is used to iterate over the raw logs and unpacked data for ApprovalForAll events raised by the ERC721Metadata contract.
|
|
type ERC721MetadataApprovalForAllIterator struct {
|
|
Event *ERC721MetadataApprovalForAll // 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 *ERC721MetadataApprovalForAllIterator) 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(ERC721MetadataApprovalForAll)
|
|
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(ERC721MetadataApprovalForAll)
|
|
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 *ERC721MetadataApprovalForAllIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ERC721MetadataApprovalForAllIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ERC721MetadataApprovalForAll represents a ApprovalForAll event raised by the ERC721Metadata contract.
|
|
type ERC721MetadataApprovalForAll struct {
|
|
Owner common.Address
|
|
Operator common.Address
|
|
Approved bool
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterApprovalForAll is a free log retrieval operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_ERC721Metadata *ERC721MetadataFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*ERC721MetadataApprovalForAllIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721Metadata.contract.FilterLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721MetadataApprovalForAllIterator{contract: _ERC721Metadata.contract, event: "ApprovalForAll", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchApprovalForAll is a free log subscription operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_ERC721Metadata *ERC721MetadataFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *ERC721MetadataApprovalForAll, owner []common.Address, operator []common.Address) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721Metadata.contract.WatchLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
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(ERC721MetadataApprovalForAll)
|
|
if err := _ERC721Metadata.contract.UnpackLog(event, "ApprovalForAll", 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
|
|
}
|
|
|
|
// ParseApprovalForAll is a log parse operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_ERC721Metadata *ERC721MetadataFilterer) ParseApprovalForAll(log types.Log) (*ERC721MetadataApprovalForAll, error) {
|
|
event := new(ERC721MetadataApprovalForAll)
|
|
if err := _ERC721Metadata.contract.UnpackLog(event, "ApprovalForAll", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ERC721MetadataTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ERC721Metadata contract.
|
|
type ERC721MetadataTransferIterator struct {
|
|
Event *ERC721MetadataTransfer // 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 *ERC721MetadataTransferIterator) 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(ERC721MetadataTransfer)
|
|
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(ERC721MetadataTransfer)
|
|
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 *ERC721MetadataTransferIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ERC721MetadataTransferIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ERC721MetadataTransfer represents a Transfer event raised by the ERC721Metadata contract.
|
|
type ERC721MetadataTransfer struct {
|
|
From common.Address
|
|
To common.Address
|
|
TokenId *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 indexed tokenId)
|
|
func (_ERC721Metadata *ERC721MetadataFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, tokenId []*big.Int) (*ERC721MetadataTransferIterator, error) {
|
|
|
|
var fromRule []interface{}
|
|
for _, fromItem := range from {
|
|
fromRule = append(fromRule, fromItem)
|
|
}
|
|
var toRule []interface{}
|
|
for _, toItem := range to {
|
|
toRule = append(toRule, toItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721Metadata.contract.FilterLogs(opts, "Transfer", fromRule, toRule, tokenIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ERC721MetadataTransferIterator{contract: _ERC721Metadata.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 indexed tokenId)
|
|
func (_ERC721Metadata *ERC721MetadataFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC721MetadataTransfer, from []common.Address, to []common.Address, tokenId []*big.Int) (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)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _ERC721Metadata.contract.WatchLogs(opts, "Transfer", fromRule, toRule, tokenIdRule)
|
|
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(ERC721MetadataTransfer)
|
|
if err := _ERC721Metadata.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 indexed tokenId)
|
|
func (_ERC721Metadata *ERC721MetadataFilterer) ParseTransfer(log types.Log) (*ERC721MetadataTransfer, error) {
|
|
event := new(ERC721MetadataTransfer)
|
|
if err := _ERC721Metadata.contract.UnpackLog(event, "Transfer", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// IERC165ABI is the input ABI used to generate the binding from.
|
|
const IERC165ABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"
|
|
|
|
// IERC165FuncSigs maps the 4-byte function signature to its string representation.
|
|
var IERC165FuncSigs = map[string]string{
|
|
"01ffc9a7": "supportsInterface(bytes4)",
|
|
}
|
|
|
|
// IERC165 is an auto generated Go binding around an Ethereum contract.
|
|
type IERC165 struct {
|
|
IERC165Caller // Read-only binding to the contract
|
|
IERC165Transactor // Write-only binding to the contract
|
|
IERC165Filterer // Log filterer for contract events
|
|
}
|
|
|
|
// IERC165Caller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type IERC165Caller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// IERC165Transactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type IERC165Transactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// IERC165Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type IERC165Filterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// IERC165Session is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type IERC165Session struct {
|
|
Contract *IERC165 // 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
|
|
}
|
|
|
|
// IERC165CallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type IERC165CallerSession struct {
|
|
Contract *IERC165Caller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// IERC165TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type IERC165TransactorSession struct {
|
|
Contract *IERC165Transactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// IERC165Raw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type IERC165Raw struct {
|
|
Contract *IERC165 // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// IERC165CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type IERC165CallerRaw struct {
|
|
Contract *IERC165Caller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// IERC165TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type IERC165TransactorRaw struct {
|
|
Contract *IERC165Transactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewIERC165 creates a new instance of IERC165, bound to a specific deployed contract.
|
|
func NewIERC165(address common.Address, backend bind.ContractBackend) (*IERC165, error) {
|
|
contract, err := bindIERC165(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC165{IERC165Caller: IERC165Caller{contract: contract}, IERC165Transactor: IERC165Transactor{contract: contract}, IERC165Filterer: IERC165Filterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewIERC165Caller creates a new read-only instance of IERC165, bound to a specific deployed contract.
|
|
func NewIERC165Caller(address common.Address, caller bind.ContractCaller) (*IERC165Caller, error) {
|
|
contract, err := bindIERC165(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC165Caller{contract: contract}, nil
|
|
}
|
|
|
|
// NewIERC165Transactor creates a new write-only instance of IERC165, bound to a specific deployed contract.
|
|
func NewIERC165Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC165Transactor, error) {
|
|
contract, err := bindIERC165(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC165Transactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewIERC165Filterer creates a new log filterer instance of IERC165, bound to a specific deployed contract.
|
|
func NewIERC165Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC165Filterer, error) {
|
|
contract, err := bindIERC165(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC165Filterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindIERC165 binds a generic wrapper to an already deployed contract.
|
|
func bindIERC165(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(IERC165ABI))
|
|
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 (_IERC165 *IERC165Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _IERC165.Contract.IERC165Caller.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 (_IERC165 *IERC165Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _IERC165.Contract.IERC165Transactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_IERC165 *IERC165Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _IERC165.Contract.IERC165Transactor.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 (_IERC165 *IERC165CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _IERC165.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 (_IERC165 *IERC165TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _IERC165.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_IERC165 *IERC165TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _IERC165.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_IERC165 *IERC165Caller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _IERC165.contract.Call(opts, &out, "supportsInterface", interfaceId)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_IERC165 *IERC165Session) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _IERC165.Contract.SupportsInterface(&_IERC165.CallOpts, interfaceId)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_IERC165 *IERC165CallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _IERC165.Contract.SupportsInterface(&_IERC165.CallOpts, interfaceId)
|
|
}
|
|
|
|
// IERC721ABI is the input ABI used to generate the binding from.
|
|
const IERC721ABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"getApproved\",\"outputs\":[{\"name\":\"operator\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"ownerOf\",\"outputs\":[{\"name\":\"owner\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"balance\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"operator\",\"type\":\"address\"},{\"name\":\"_approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"approved\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"}]"
|
|
|
|
// IERC721FuncSigs maps the 4-byte function signature to its string representation.
|
|
var IERC721FuncSigs = map[string]string{
|
|
"095ea7b3": "approve(address,uint256)",
|
|
"70a08231": "balanceOf(address)",
|
|
"081812fc": "getApproved(uint256)",
|
|
"e985e9c5": "isApprovedForAll(address,address)",
|
|
"6352211e": "ownerOf(uint256)",
|
|
"42842e0e": "safeTransferFrom(address,address,uint256)",
|
|
"b88d4fde": "safeTransferFrom(address,address,uint256,bytes)",
|
|
"a22cb465": "setApprovalForAll(address,bool)",
|
|
"01ffc9a7": "supportsInterface(bytes4)",
|
|
"23b872dd": "transferFrom(address,address,uint256)",
|
|
}
|
|
|
|
// IERC721 is an auto generated Go binding around an Ethereum contract.
|
|
type IERC721 struct {
|
|
IERC721Caller // Read-only binding to the contract
|
|
IERC721Transactor // Write-only binding to the contract
|
|
IERC721Filterer // Log filterer for contract events
|
|
}
|
|
|
|
// IERC721Caller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type IERC721Caller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// IERC721Transactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type IERC721Transactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// IERC721Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type IERC721Filterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// IERC721Session is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type IERC721Session struct {
|
|
Contract *IERC721 // 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
|
|
}
|
|
|
|
// IERC721CallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type IERC721CallerSession struct {
|
|
Contract *IERC721Caller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// IERC721TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type IERC721TransactorSession struct {
|
|
Contract *IERC721Transactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// IERC721Raw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type IERC721Raw struct {
|
|
Contract *IERC721 // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// IERC721CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type IERC721CallerRaw struct {
|
|
Contract *IERC721Caller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// IERC721TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type IERC721TransactorRaw struct {
|
|
Contract *IERC721Transactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewIERC721 creates a new instance of IERC721, bound to a specific deployed contract.
|
|
func NewIERC721(address common.Address, backend bind.ContractBackend) (*IERC721, error) {
|
|
contract, err := bindIERC721(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721{IERC721Caller: IERC721Caller{contract: contract}, IERC721Transactor: IERC721Transactor{contract: contract}, IERC721Filterer: IERC721Filterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewIERC721Caller creates a new read-only instance of IERC721, bound to a specific deployed contract.
|
|
func NewIERC721Caller(address common.Address, caller bind.ContractCaller) (*IERC721Caller, error) {
|
|
contract, err := bindIERC721(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721Caller{contract: contract}, nil
|
|
}
|
|
|
|
// NewIERC721Transactor creates a new write-only instance of IERC721, bound to a specific deployed contract.
|
|
func NewIERC721Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC721Transactor, error) {
|
|
contract, err := bindIERC721(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721Transactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewIERC721Filterer creates a new log filterer instance of IERC721, bound to a specific deployed contract.
|
|
func NewIERC721Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC721Filterer, error) {
|
|
contract, err := bindIERC721(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721Filterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindIERC721 binds a generic wrapper to an already deployed contract.
|
|
func bindIERC721(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(IERC721ABI))
|
|
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 (_IERC721 *IERC721Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _IERC721.Contract.IERC721Caller.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 (_IERC721 *IERC721Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _IERC721.Contract.IERC721Transactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_IERC721 *IERC721Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _IERC721.Contract.IERC721Transactor.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 (_IERC721 *IERC721CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _IERC721.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 (_IERC721 *IERC721TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _IERC721.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_IERC721 *IERC721TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _IERC721.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address owner) view returns(uint256 balance)
|
|
func (_IERC721 *IERC721Caller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _IERC721.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 balance)
|
|
func (_IERC721 *IERC721Session) BalanceOf(owner common.Address) (*big.Int, error) {
|
|
return _IERC721.Contract.BalanceOf(&_IERC721.CallOpts, owner)
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address owner) view returns(uint256 balance)
|
|
func (_IERC721 *IERC721CallerSession) BalanceOf(owner common.Address) (*big.Int, error) {
|
|
return _IERC721.Contract.BalanceOf(&_IERC721.CallOpts, owner)
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address operator)
|
|
func (_IERC721 *IERC721Caller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _IERC721.contract.Call(opts, &out, "getApproved", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address operator)
|
|
func (_IERC721 *IERC721Session) GetApproved(tokenId *big.Int) (common.Address, error) {
|
|
return _IERC721.Contract.GetApproved(&_IERC721.CallOpts, tokenId)
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address operator)
|
|
func (_IERC721 *IERC721CallerSession) GetApproved(tokenId *big.Int) (common.Address, error) {
|
|
return _IERC721.Contract.GetApproved(&_IERC721.CallOpts, tokenId)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_IERC721 *IERC721Caller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error) {
|
|
var out []interface{}
|
|
err := _IERC721.contract.Call(opts, &out, "isApprovedForAll", owner, operator)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_IERC721 *IERC721Session) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _IERC721.Contract.IsApprovedForAll(&_IERC721.CallOpts, owner, operator)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_IERC721 *IERC721CallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _IERC721.Contract.IsApprovedForAll(&_IERC721.CallOpts, owner, operator)
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address owner)
|
|
func (_IERC721 *IERC721Caller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _IERC721.contract.Call(opts, &out, "ownerOf", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address owner)
|
|
func (_IERC721 *IERC721Session) OwnerOf(tokenId *big.Int) (common.Address, error) {
|
|
return _IERC721.Contract.OwnerOf(&_IERC721.CallOpts, tokenId)
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address owner)
|
|
func (_IERC721 *IERC721CallerSession) OwnerOf(tokenId *big.Int) (common.Address, error) {
|
|
return _IERC721.Contract.OwnerOf(&_IERC721.CallOpts, tokenId)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_IERC721 *IERC721Caller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _IERC721.contract.Call(opts, &out, "supportsInterface", interfaceId)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_IERC721 *IERC721Session) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _IERC721.Contract.SupportsInterface(&_IERC721.CallOpts, interfaceId)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_IERC721 *IERC721CallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _IERC721.Contract.SupportsInterface(&_IERC721.CallOpts, interfaceId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_IERC721 *IERC721Transactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721.contract.Transact(opts, "approve", to, tokenId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_IERC721 *IERC721Session) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721.Contract.Approve(&_IERC721.TransactOpts, to, tokenId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_IERC721 *IERC721TransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721.Contract.Approve(&_IERC721.TransactOpts, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721 *IERC721Transactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721.contract.Transact(opts, "safeTransferFrom", from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721 *IERC721Session) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721.Contract.SafeTransferFrom(&_IERC721.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721 *IERC721TransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721.Contract.SafeTransferFrom(&_IERC721.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes data) returns()
|
|
func (_IERC721 *IERC721Transactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error) {
|
|
return _IERC721.contract.Transact(opts, "safeTransferFrom0", from, to, tokenId, data)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes data) returns()
|
|
func (_IERC721 *IERC721Session) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error) {
|
|
return _IERC721.Contract.SafeTransferFrom0(&_IERC721.TransactOpts, from, to, tokenId, data)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes data) returns()
|
|
func (_IERC721 *IERC721TransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error) {
|
|
return _IERC721.Contract.SafeTransferFrom0(&_IERC721.TransactOpts, from, to, tokenId, data)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address operator, bool _approved) returns()
|
|
func (_IERC721 *IERC721Transactor) SetApprovalForAll(opts *bind.TransactOpts, operator common.Address, _approved bool) (*types.Transaction, error) {
|
|
return _IERC721.contract.Transact(opts, "setApprovalForAll", operator, _approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address operator, bool _approved) returns()
|
|
func (_IERC721 *IERC721Session) SetApprovalForAll(operator common.Address, _approved bool) (*types.Transaction, error) {
|
|
return _IERC721.Contract.SetApprovalForAll(&_IERC721.TransactOpts, operator, _approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address operator, bool _approved) returns()
|
|
func (_IERC721 *IERC721TransactorSession) SetApprovalForAll(operator common.Address, _approved bool) (*types.Transaction, error) {
|
|
return _IERC721.Contract.SetApprovalForAll(&_IERC721.TransactOpts, operator, _approved)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721 *IERC721Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721.contract.Transact(opts, "transferFrom", from, to, tokenId)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721 *IERC721Session) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721.Contract.TransferFrom(&_IERC721.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721 *IERC721TransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721.Contract.TransferFrom(&_IERC721.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// IERC721ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the IERC721 contract.
|
|
type IERC721ApprovalIterator struct {
|
|
Event *IERC721Approval // 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 *IERC721ApprovalIterator) 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(IERC721Approval)
|
|
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(IERC721Approval)
|
|
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 *IERC721ApprovalIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *IERC721ApprovalIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// IERC721Approval represents a Approval event raised by the IERC721 contract.
|
|
type IERC721Approval struct {
|
|
Owner common.Address
|
|
Approved common.Address
|
|
TokenId *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 approved, uint256 indexed tokenId)
|
|
func (_IERC721 *IERC721Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, tokenId []*big.Int) (*IERC721ApprovalIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var approvedRule []interface{}
|
|
for _, approvedItem := range approved {
|
|
approvedRule = append(approvedRule, approvedItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721.contract.FilterLogs(opts, "Approval", ownerRule, approvedRule, tokenIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721ApprovalIterator{contract: _IERC721.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 approved, uint256 indexed tokenId)
|
|
func (_IERC721 *IERC721Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC721Approval, owner []common.Address, approved []common.Address, tokenId []*big.Int) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var approvedRule []interface{}
|
|
for _, approvedItem := range approved {
|
|
approvedRule = append(approvedRule, approvedItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721.contract.WatchLogs(opts, "Approval", ownerRule, approvedRule, tokenIdRule)
|
|
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(IERC721Approval)
|
|
if err := _IERC721.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 approved, uint256 indexed tokenId)
|
|
func (_IERC721 *IERC721Filterer) ParseApproval(log types.Log) (*IERC721Approval, error) {
|
|
event := new(IERC721Approval)
|
|
if err := _IERC721.contract.UnpackLog(event, "Approval", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// IERC721ApprovalForAllIterator is returned from FilterApprovalForAll and is used to iterate over the raw logs and unpacked data for ApprovalForAll events raised by the IERC721 contract.
|
|
type IERC721ApprovalForAllIterator struct {
|
|
Event *IERC721ApprovalForAll // 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 *IERC721ApprovalForAllIterator) 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(IERC721ApprovalForAll)
|
|
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(IERC721ApprovalForAll)
|
|
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 *IERC721ApprovalForAllIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *IERC721ApprovalForAllIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// IERC721ApprovalForAll represents a ApprovalForAll event raised by the IERC721 contract.
|
|
type IERC721ApprovalForAll struct {
|
|
Owner common.Address
|
|
Operator common.Address
|
|
Approved bool
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterApprovalForAll is a free log retrieval operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_IERC721 *IERC721Filterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*IERC721ApprovalForAllIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721.contract.FilterLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721ApprovalForAllIterator{contract: _IERC721.contract, event: "ApprovalForAll", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchApprovalForAll is a free log subscription operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_IERC721 *IERC721Filterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *IERC721ApprovalForAll, owner []common.Address, operator []common.Address) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721.contract.WatchLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
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(IERC721ApprovalForAll)
|
|
if err := _IERC721.contract.UnpackLog(event, "ApprovalForAll", 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
|
|
}
|
|
|
|
// ParseApprovalForAll is a log parse operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_IERC721 *IERC721Filterer) ParseApprovalForAll(log types.Log) (*IERC721ApprovalForAll, error) {
|
|
event := new(IERC721ApprovalForAll)
|
|
if err := _IERC721.contract.UnpackLog(event, "ApprovalForAll", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// IERC721TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the IERC721 contract.
|
|
type IERC721TransferIterator struct {
|
|
Event *IERC721Transfer // 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 *IERC721TransferIterator) 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(IERC721Transfer)
|
|
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(IERC721Transfer)
|
|
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 *IERC721TransferIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *IERC721TransferIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// IERC721Transfer represents a Transfer event raised by the IERC721 contract.
|
|
type IERC721Transfer struct {
|
|
From common.Address
|
|
To common.Address
|
|
TokenId *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 indexed tokenId)
|
|
func (_IERC721 *IERC721Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, tokenId []*big.Int) (*IERC721TransferIterator, error) {
|
|
|
|
var fromRule []interface{}
|
|
for _, fromItem := range from {
|
|
fromRule = append(fromRule, fromItem)
|
|
}
|
|
var toRule []interface{}
|
|
for _, toItem := range to {
|
|
toRule = append(toRule, toItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721.contract.FilterLogs(opts, "Transfer", fromRule, toRule, tokenIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721TransferIterator{contract: _IERC721.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 indexed tokenId)
|
|
func (_IERC721 *IERC721Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC721Transfer, from []common.Address, to []common.Address, tokenId []*big.Int) (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)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721.contract.WatchLogs(opts, "Transfer", fromRule, toRule, tokenIdRule)
|
|
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(IERC721Transfer)
|
|
if err := _IERC721.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 indexed tokenId)
|
|
func (_IERC721 *IERC721Filterer) ParseTransfer(log types.Log) (*IERC721Transfer, error) {
|
|
event := new(IERC721Transfer)
|
|
if err := _IERC721.contract.UnpackLog(event, "Transfer", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// IERC721EnumerableABI is the input ABI used to generate the binding from.
|
|
const IERC721EnumerableABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"getApproved\",\"outputs\":[{\"name\":\"operator\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"tokenOfOwnerByIndex\",\"outputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"tokenByIndex\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"ownerOf\",\"outputs\":[{\"name\":\"owner\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"balance\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"operator\",\"type\":\"address\"},{\"name\":\"_approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"approved\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"}]"
|
|
|
|
// IERC721EnumerableFuncSigs maps the 4-byte function signature to its string representation.
|
|
var IERC721EnumerableFuncSigs = map[string]string{
|
|
"095ea7b3": "approve(address,uint256)",
|
|
"70a08231": "balanceOf(address)",
|
|
"081812fc": "getApproved(uint256)",
|
|
"e985e9c5": "isApprovedForAll(address,address)",
|
|
"6352211e": "ownerOf(uint256)",
|
|
"42842e0e": "safeTransferFrom(address,address,uint256)",
|
|
"b88d4fde": "safeTransferFrom(address,address,uint256,bytes)",
|
|
"a22cb465": "setApprovalForAll(address,bool)",
|
|
"01ffc9a7": "supportsInterface(bytes4)",
|
|
"4f6ccce7": "tokenByIndex(uint256)",
|
|
"2f745c59": "tokenOfOwnerByIndex(address,uint256)",
|
|
"18160ddd": "totalSupply()",
|
|
"23b872dd": "transferFrom(address,address,uint256)",
|
|
}
|
|
|
|
// IERC721Enumerable is an auto generated Go binding around an Ethereum contract.
|
|
type IERC721Enumerable struct {
|
|
IERC721EnumerableCaller // Read-only binding to the contract
|
|
IERC721EnumerableTransactor // Write-only binding to the contract
|
|
IERC721EnumerableFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// IERC721EnumerableCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type IERC721EnumerableCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// IERC721EnumerableTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type IERC721EnumerableTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// IERC721EnumerableFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type IERC721EnumerableFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// IERC721EnumerableSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type IERC721EnumerableSession struct {
|
|
Contract *IERC721Enumerable // 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
|
|
}
|
|
|
|
// IERC721EnumerableCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type IERC721EnumerableCallerSession struct {
|
|
Contract *IERC721EnumerableCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// IERC721EnumerableTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type IERC721EnumerableTransactorSession struct {
|
|
Contract *IERC721EnumerableTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// IERC721EnumerableRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type IERC721EnumerableRaw struct {
|
|
Contract *IERC721Enumerable // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// IERC721EnumerableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type IERC721EnumerableCallerRaw struct {
|
|
Contract *IERC721EnumerableCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// IERC721EnumerableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type IERC721EnumerableTransactorRaw struct {
|
|
Contract *IERC721EnumerableTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewIERC721Enumerable creates a new instance of IERC721Enumerable, bound to a specific deployed contract.
|
|
func NewIERC721Enumerable(address common.Address, backend bind.ContractBackend) (*IERC721Enumerable, error) {
|
|
contract, err := bindIERC721Enumerable(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721Enumerable{IERC721EnumerableCaller: IERC721EnumerableCaller{contract: contract}, IERC721EnumerableTransactor: IERC721EnumerableTransactor{contract: contract}, IERC721EnumerableFilterer: IERC721EnumerableFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewIERC721EnumerableCaller creates a new read-only instance of IERC721Enumerable, bound to a specific deployed contract.
|
|
func NewIERC721EnumerableCaller(address common.Address, caller bind.ContractCaller) (*IERC721EnumerableCaller, error) {
|
|
contract, err := bindIERC721Enumerable(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721EnumerableCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewIERC721EnumerableTransactor creates a new write-only instance of IERC721Enumerable, bound to a specific deployed contract.
|
|
func NewIERC721EnumerableTransactor(address common.Address, transactor bind.ContractTransactor) (*IERC721EnumerableTransactor, error) {
|
|
contract, err := bindIERC721Enumerable(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721EnumerableTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewIERC721EnumerableFilterer creates a new log filterer instance of IERC721Enumerable, bound to a specific deployed contract.
|
|
func NewIERC721EnumerableFilterer(address common.Address, filterer bind.ContractFilterer) (*IERC721EnumerableFilterer, error) {
|
|
contract, err := bindIERC721Enumerable(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721EnumerableFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindIERC721Enumerable binds a generic wrapper to an already deployed contract.
|
|
func bindIERC721Enumerable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(IERC721EnumerableABI))
|
|
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 (_IERC721Enumerable *IERC721EnumerableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _IERC721Enumerable.Contract.IERC721EnumerableCaller.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 (_IERC721Enumerable *IERC721EnumerableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _IERC721Enumerable.Contract.IERC721EnumerableTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_IERC721Enumerable *IERC721EnumerableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _IERC721Enumerable.Contract.IERC721EnumerableTransactor.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 (_IERC721Enumerable *IERC721EnumerableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _IERC721Enumerable.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 (_IERC721Enumerable *IERC721EnumerableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _IERC721Enumerable.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_IERC721Enumerable *IERC721EnumerableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _IERC721Enumerable.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address owner) view returns(uint256 balance)
|
|
func (_IERC721Enumerable *IERC721EnumerableCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _IERC721Enumerable.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 balance)
|
|
func (_IERC721Enumerable *IERC721EnumerableSession) BalanceOf(owner common.Address) (*big.Int, error) {
|
|
return _IERC721Enumerable.Contract.BalanceOf(&_IERC721Enumerable.CallOpts, owner)
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address owner) view returns(uint256 balance)
|
|
func (_IERC721Enumerable *IERC721EnumerableCallerSession) BalanceOf(owner common.Address) (*big.Int, error) {
|
|
return _IERC721Enumerable.Contract.BalanceOf(&_IERC721Enumerable.CallOpts, owner)
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address operator)
|
|
func (_IERC721Enumerable *IERC721EnumerableCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _IERC721Enumerable.contract.Call(opts, &out, "getApproved", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address operator)
|
|
func (_IERC721Enumerable *IERC721EnumerableSession) GetApproved(tokenId *big.Int) (common.Address, error) {
|
|
return _IERC721Enumerable.Contract.GetApproved(&_IERC721Enumerable.CallOpts, tokenId)
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address operator)
|
|
func (_IERC721Enumerable *IERC721EnumerableCallerSession) GetApproved(tokenId *big.Int) (common.Address, error) {
|
|
return _IERC721Enumerable.Contract.GetApproved(&_IERC721Enumerable.CallOpts, tokenId)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_IERC721Enumerable *IERC721EnumerableCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error) {
|
|
var out []interface{}
|
|
err := _IERC721Enumerable.contract.Call(opts, &out, "isApprovedForAll", owner, operator)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_IERC721Enumerable *IERC721EnumerableSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _IERC721Enumerable.Contract.IsApprovedForAll(&_IERC721Enumerable.CallOpts, owner, operator)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_IERC721Enumerable *IERC721EnumerableCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _IERC721Enumerable.Contract.IsApprovedForAll(&_IERC721Enumerable.CallOpts, owner, operator)
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address owner)
|
|
func (_IERC721Enumerable *IERC721EnumerableCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _IERC721Enumerable.contract.Call(opts, &out, "ownerOf", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address owner)
|
|
func (_IERC721Enumerable *IERC721EnumerableSession) OwnerOf(tokenId *big.Int) (common.Address, error) {
|
|
return _IERC721Enumerable.Contract.OwnerOf(&_IERC721Enumerable.CallOpts, tokenId)
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address owner)
|
|
func (_IERC721Enumerable *IERC721EnumerableCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error) {
|
|
return _IERC721Enumerable.Contract.OwnerOf(&_IERC721Enumerable.CallOpts, tokenId)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_IERC721Enumerable *IERC721EnumerableCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _IERC721Enumerable.contract.Call(opts, &out, "supportsInterface", interfaceId)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_IERC721Enumerable *IERC721EnumerableSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _IERC721Enumerable.Contract.SupportsInterface(&_IERC721Enumerable.CallOpts, interfaceId)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_IERC721Enumerable *IERC721EnumerableCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _IERC721Enumerable.Contract.SupportsInterface(&_IERC721Enumerable.CallOpts, interfaceId)
|
|
}
|
|
|
|
// TokenByIndex is a free data retrieval call binding the contract method 0x4f6ccce7.
|
|
//
|
|
// Solidity: function tokenByIndex(uint256 index) view returns(uint256)
|
|
func (_IERC721Enumerable *IERC721EnumerableCaller) TokenByIndex(opts *bind.CallOpts, index *big.Int) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _IERC721Enumerable.contract.Call(opts, &out, "tokenByIndex", index)
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// TokenByIndex is a free data retrieval call binding the contract method 0x4f6ccce7.
|
|
//
|
|
// Solidity: function tokenByIndex(uint256 index) view returns(uint256)
|
|
func (_IERC721Enumerable *IERC721EnumerableSession) TokenByIndex(index *big.Int) (*big.Int, error) {
|
|
return _IERC721Enumerable.Contract.TokenByIndex(&_IERC721Enumerable.CallOpts, index)
|
|
}
|
|
|
|
// TokenByIndex is a free data retrieval call binding the contract method 0x4f6ccce7.
|
|
//
|
|
// Solidity: function tokenByIndex(uint256 index) view returns(uint256)
|
|
func (_IERC721Enumerable *IERC721EnumerableCallerSession) TokenByIndex(index *big.Int) (*big.Int, error) {
|
|
return _IERC721Enumerable.Contract.TokenByIndex(&_IERC721Enumerable.CallOpts, index)
|
|
}
|
|
|
|
// TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59.
|
|
//
|
|
// Solidity: function tokenOfOwnerByIndex(address owner, uint256 index) view returns(uint256 tokenId)
|
|
func (_IERC721Enumerable *IERC721EnumerableCaller) TokenOfOwnerByIndex(opts *bind.CallOpts, owner common.Address, index *big.Int) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _IERC721Enumerable.contract.Call(opts, &out, "tokenOfOwnerByIndex", owner, index)
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59.
|
|
//
|
|
// Solidity: function tokenOfOwnerByIndex(address owner, uint256 index) view returns(uint256 tokenId)
|
|
func (_IERC721Enumerable *IERC721EnumerableSession) TokenOfOwnerByIndex(owner common.Address, index *big.Int) (*big.Int, error) {
|
|
return _IERC721Enumerable.Contract.TokenOfOwnerByIndex(&_IERC721Enumerable.CallOpts, owner, index)
|
|
}
|
|
|
|
// TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59.
|
|
//
|
|
// Solidity: function tokenOfOwnerByIndex(address owner, uint256 index) view returns(uint256 tokenId)
|
|
func (_IERC721Enumerable *IERC721EnumerableCallerSession) TokenOfOwnerByIndex(owner common.Address, index *big.Int) (*big.Int, error) {
|
|
return _IERC721Enumerable.Contract.TokenOfOwnerByIndex(&_IERC721Enumerable.CallOpts, owner, index)
|
|
}
|
|
|
|
// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
|
|
//
|
|
// Solidity: function totalSupply() view returns(uint256)
|
|
func (_IERC721Enumerable *IERC721EnumerableCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _IERC721Enumerable.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 (_IERC721Enumerable *IERC721EnumerableSession) TotalSupply() (*big.Int, error) {
|
|
return _IERC721Enumerable.Contract.TotalSupply(&_IERC721Enumerable.CallOpts)
|
|
}
|
|
|
|
// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
|
|
//
|
|
// Solidity: function totalSupply() view returns(uint256)
|
|
func (_IERC721Enumerable *IERC721EnumerableCallerSession) TotalSupply() (*big.Int, error) {
|
|
return _IERC721Enumerable.Contract.TotalSupply(&_IERC721Enumerable.CallOpts)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_IERC721Enumerable *IERC721EnumerableTransactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Enumerable.contract.Transact(opts, "approve", to, tokenId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_IERC721Enumerable *IERC721EnumerableSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Enumerable.Contract.Approve(&_IERC721Enumerable.TransactOpts, to, tokenId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_IERC721Enumerable *IERC721EnumerableTransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Enumerable.Contract.Approve(&_IERC721Enumerable.TransactOpts, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721Enumerable *IERC721EnumerableTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Enumerable.contract.Transact(opts, "safeTransferFrom", from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721Enumerable *IERC721EnumerableSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Enumerable.Contract.SafeTransferFrom(&_IERC721Enumerable.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721Enumerable *IERC721EnumerableTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Enumerable.Contract.SafeTransferFrom(&_IERC721Enumerable.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes data) returns()
|
|
func (_IERC721Enumerable *IERC721EnumerableTransactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error) {
|
|
return _IERC721Enumerable.contract.Transact(opts, "safeTransferFrom0", from, to, tokenId, data)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes data) returns()
|
|
func (_IERC721Enumerable *IERC721EnumerableSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error) {
|
|
return _IERC721Enumerable.Contract.SafeTransferFrom0(&_IERC721Enumerable.TransactOpts, from, to, tokenId, data)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes data) returns()
|
|
func (_IERC721Enumerable *IERC721EnumerableTransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error) {
|
|
return _IERC721Enumerable.Contract.SafeTransferFrom0(&_IERC721Enumerable.TransactOpts, from, to, tokenId, data)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address operator, bool _approved) returns()
|
|
func (_IERC721Enumerable *IERC721EnumerableTransactor) SetApprovalForAll(opts *bind.TransactOpts, operator common.Address, _approved bool) (*types.Transaction, error) {
|
|
return _IERC721Enumerable.contract.Transact(opts, "setApprovalForAll", operator, _approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address operator, bool _approved) returns()
|
|
func (_IERC721Enumerable *IERC721EnumerableSession) SetApprovalForAll(operator common.Address, _approved bool) (*types.Transaction, error) {
|
|
return _IERC721Enumerable.Contract.SetApprovalForAll(&_IERC721Enumerable.TransactOpts, operator, _approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address operator, bool _approved) returns()
|
|
func (_IERC721Enumerable *IERC721EnumerableTransactorSession) SetApprovalForAll(operator common.Address, _approved bool) (*types.Transaction, error) {
|
|
return _IERC721Enumerable.Contract.SetApprovalForAll(&_IERC721Enumerable.TransactOpts, operator, _approved)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721Enumerable *IERC721EnumerableTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Enumerable.contract.Transact(opts, "transferFrom", from, to, tokenId)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721Enumerable *IERC721EnumerableSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Enumerable.Contract.TransferFrom(&_IERC721Enumerable.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721Enumerable *IERC721EnumerableTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Enumerable.Contract.TransferFrom(&_IERC721Enumerable.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// IERC721EnumerableApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the IERC721Enumerable contract.
|
|
type IERC721EnumerableApprovalIterator struct {
|
|
Event *IERC721EnumerableApproval // 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 *IERC721EnumerableApprovalIterator) 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(IERC721EnumerableApproval)
|
|
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(IERC721EnumerableApproval)
|
|
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 *IERC721EnumerableApprovalIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *IERC721EnumerableApprovalIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// IERC721EnumerableApproval represents a Approval event raised by the IERC721Enumerable contract.
|
|
type IERC721EnumerableApproval struct {
|
|
Owner common.Address
|
|
Approved common.Address
|
|
TokenId *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 approved, uint256 indexed tokenId)
|
|
func (_IERC721Enumerable *IERC721EnumerableFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, tokenId []*big.Int) (*IERC721EnumerableApprovalIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var approvedRule []interface{}
|
|
for _, approvedItem := range approved {
|
|
approvedRule = append(approvedRule, approvedItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721Enumerable.contract.FilterLogs(opts, "Approval", ownerRule, approvedRule, tokenIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721EnumerableApprovalIterator{contract: _IERC721Enumerable.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 approved, uint256 indexed tokenId)
|
|
func (_IERC721Enumerable *IERC721EnumerableFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC721EnumerableApproval, owner []common.Address, approved []common.Address, tokenId []*big.Int) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var approvedRule []interface{}
|
|
for _, approvedItem := range approved {
|
|
approvedRule = append(approvedRule, approvedItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721Enumerable.contract.WatchLogs(opts, "Approval", ownerRule, approvedRule, tokenIdRule)
|
|
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(IERC721EnumerableApproval)
|
|
if err := _IERC721Enumerable.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 approved, uint256 indexed tokenId)
|
|
func (_IERC721Enumerable *IERC721EnumerableFilterer) ParseApproval(log types.Log) (*IERC721EnumerableApproval, error) {
|
|
event := new(IERC721EnumerableApproval)
|
|
if err := _IERC721Enumerable.contract.UnpackLog(event, "Approval", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// IERC721EnumerableApprovalForAllIterator is returned from FilterApprovalForAll and is used to iterate over the raw logs and unpacked data for ApprovalForAll events raised by the IERC721Enumerable contract.
|
|
type IERC721EnumerableApprovalForAllIterator struct {
|
|
Event *IERC721EnumerableApprovalForAll // 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 *IERC721EnumerableApprovalForAllIterator) 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(IERC721EnumerableApprovalForAll)
|
|
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(IERC721EnumerableApprovalForAll)
|
|
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 *IERC721EnumerableApprovalForAllIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *IERC721EnumerableApprovalForAllIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// IERC721EnumerableApprovalForAll represents a ApprovalForAll event raised by the IERC721Enumerable contract.
|
|
type IERC721EnumerableApprovalForAll struct {
|
|
Owner common.Address
|
|
Operator common.Address
|
|
Approved bool
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterApprovalForAll is a free log retrieval operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_IERC721Enumerable *IERC721EnumerableFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*IERC721EnumerableApprovalForAllIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721Enumerable.contract.FilterLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721EnumerableApprovalForAllIterator{contract: _IERC721Enumerable.contract, event: "ApprovalForAll", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchApprovalForAll is a free log subscription operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_IERC721Enumerable *IERC721EnumerableFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *IERC721EnumerableApprovalForAll, owner []common.Address, operator []common.Address) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721Enumerable.contract.WatchLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
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(IERC721EnumerableApprovalForAll)
|
|
if err := _IERC721Enumerable.contract.UnpackLog(event, "ApprovalForAll", 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
|
|
}
|
|
|
|
// ParseApprovalForAll is a log parse operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_IERC721Enumerable *IERC721EnumerableFilterer) ParseApprovalForAll(log types.Log) (*IERC721EnumerableApprovalForAll, error) {
|
|
event := new(IERC721EnumerableApprovalForAll)
|
|
if err := _IERC721Enumerable.contract.UnpackLog(event, "ApprovalForAll", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// IERC721EnumerableTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the IERC721Enumerable contract.
|
|
type IERC721EnumerableTransferIterator struct {
|
|
Event *IERC721EnumerableTransfer // 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 *IERC721EnumerableTransferIterator) 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(IERC721EnumerableTransfer)
|
|
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(IERC721EnumerableTransfer)
|
|
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 *IERC721EnumerableTransferIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *IERC721EnumerableTransferIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// IERC721EnumerableTransfer represents a Transfer event raised by the IERC721Enumerable contract.
|
|
type IERC721EnumerableTransfer struct {
|
|
From common.Address
|
|
To common.Address
|
|
TokenId *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 indexed tokenId)
|
|
func (_IERC721Enumerable *IERC721EnumerableFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, tokenId []*big.Int) (*IERC721EnumerableTransferIterator, error) {
|
|
|
|
var fromRule []interface{}
|
|
for _, fromItem := range from {
|
|
fromRule = append(fromRule, fromItem)
|
|
}
|
|
var toRule []interface{}
|
|
for _, toItem := range to {
|
|
toRule = append(toRule, toItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721Enumerable.contract.FilterLogs(opts, "Transfer", fromRule, toRule, tokenIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721EnumerableTransferIterator{contract: _IERC721Enumerable.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 indexed tokenId)
|
|
func (_IERC721Enumerable *IERC721EnumerableFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC721EnumerableTransfer, from []common.Address, to []common.Address, tokenId []*big.Int) (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)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721Enumerable.contract.WatchLogs(opts, "Transfer", fromRule, toRule, tokenIdRule)
|
|
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(IERC721EnumerableTransfer)
|
|
if err := _IERC721Enumerable.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 indexed tokenId)
|
|
func (_IERC721Enumerable *IERC721EnumerableFilterer) ParseTransfer(log types.Log) (*IERC721EnumerableTransfer, error) {
|
|
event := new(IERC721EnumerableTransfer)
|
|
if err := _IERC721Enumerable.contract.UnpackLog(event, "Transfer", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// IERC721FullABI is the input ABI used to generate the binding from.
|
|
const IERC721FullABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"getApproved\",\"outputs\":[{\"name\":\"operator\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"tokenOfOwnerByIndex\",\"outputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"tokenByIndex\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"ownerOf\",\"outputs\":[{\"name\":\"owner\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"balance\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"operator\",\"type\":\"address\"},{\"name\":\"_approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"tokenURI\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"approved\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"}]"
|
|
|
|
// IERC721FullFuncSigs maps the 4-byte function signature to its string representation.
|
|
var IERC721FullFuncSigs = map[string]string{
|
|
"095ea7b3": "approve(address,uint256)",
|
|
"70a08231": "balanceOf(address)",
|
|
"081812fc": "getApproved(uint256)",
|
|
"e985e9c5": "isApprovedForAll(address,address)",
|
|
"06fdde03": "name()",
|
|
"6352211e": "ownerOf(uint256)",
|
|
"42842e0e": "safeTransferFrom(address,address,uint256)",
|
|
"b88d4fde": "safeTransferFrom(address,address,uint256,bytes)",
|
|
"a22cb465": "setApprovalForAll(address,bool)",
|
|
"01ffc9a7": "supportsInterface(bytes4)",
|
|
"95d89b41": "symbol()",
|
|
"4f6ccce7": "tokenByIndex(uint256)",
|
|
"2f745c59": "tokenOfOwnerByIndex(address,uint256)",
|
|
"c87b56dd": "tokenURI(uint256)",
|
|
"18160ddd": "totalSupply()",
|
|
"23b872dd": "transferFrom(address,address,uint256)",
|
|
}
|
|
|
|
// IERC721Full is an auto generated Go binding around an Ethereum contract.
|
|
type IERC721Full struct {
|
|
IERC721FullCaller // Read-only binding to the contract
|
|
IERC721FullTransactor // Write-only binding to the contract
|
|
IERC721FullFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// IERC721FullCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type IERC721FullCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// IERC721FullTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type IERC721FullTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// IERC721FullFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type IERC721FullFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// IERC721FullSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type IERC721FullSession struct {
|
|
Contract *IERC721Full // 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
|
|
}
|
|
|
|
// IERC721FullCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type IERC721FullCallerSession struct {
|
|
Contract *IERC721FullCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// IERC721FullTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type IERC721FullTransactorSession struct {
|
|
Contract *IERC721FullTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// IERC721FullRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type IERC721FullRaw struct {
|
|
Contract *IERC721Full // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// IERC721FullCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type IERC721FullCallerRaw struct {
|
|
Contract *IERC721FullCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// IERC721FullTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type IERC721FullTransactorRaw struct {
|
|
Contract *IERC721FullTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewIERC721Full creates a new instance of IERC721Full, bound to a specific deployed contract.
|
|
func NewIERC721Full(address common.Address, backend bind.ContractBackend) (*IERC721Full, error) {
|
|
contract, err := bindIERC721Full(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721Full{IERC721FullCaller: IERC721FullCaller{contract: contract}, IERC721FullTransactor: IERC721FullTransactor{contract: contract}, IERC721FullFilterer: IERC721FullFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewIERC721FullCaller creates a new read-only instance of IERC721Full, bound to a specific deployed contract.
|
|
func NewIERC721FullCaller(address common.Address, caller bind.ContractCaller) (*IERC721FullCaller, error) {
|
|
contract, err := bindIERC721Full(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721FullCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewIERC721FullTransactor creates a new write-only instance of IERC721Full, bound to a specific deployed contract.
|
|
func NewIERC721FullTransactor(address common.Address, transactor bind.ContractTransactor) (*IERC721FullTransactor, error) {
|
|
contract, err := bindIERC721Full(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721FullTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewIERC721FullFilterer creates a new log filterer instance of IERC721Full, bound to a specific deployed contract.
|
|
func NewIERC721FullFilterer(address common.Address, filterer bind.ContractFilterer) (*IERC721FullFilterer, error) {
|
|
contract, err := bindIERC721Full(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721FullFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindIERC721Full binds a generic wrapper to an already deployed contract.
|
|
func bindIERC721Full(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(IERC721FullABI))
|
|
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 (_IERC721Full *IERC721FullRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _IERC721Full.Contract.IERC721FullCaller.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 (_IERC721Full *IERC721FullRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _IERC721Full.Contract.IERC721FullTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_IERC721Full *IERC721FullRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _IERC721Full.Contract.IERC721FullTransactor.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 (_IERC721Full *IERC721FullCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _IERC721Full.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 (_IERC721Full *IERC721FullTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _IERC721Full.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_IERC721Full *IERC721FullTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _IERC721Full.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address owner) view returns(uint256 balance)
|
|
func (_IERC721Full *IERC721FullCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _IERC721Full.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 balance)
|
|
func (_IERC721Full *IERC721FullSession) BalanceOf(owner common.Address) (*big.Int, error) {
|
|
return _IERC721Full.Contract.BalanceOf(&_IERC721Full.CallOpts, owner)
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address owner) view returns(uint256 balance)
|
|
func (_IERC721Full *IERC721FullCallerSession) BalanceOf(owner common.Address) (*big.Int, error) {
|
|
return _IERC721Full.Contract.BalanceOf(&_IERC721Full.CallOpts, owner)
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address operator)
|
|
func (_IERC721Full *IERC721FullCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _IERC721Full.contract.Call(opts, &out, "getApproved", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address operator)
|
|
func (_IERC721Full *IERC721FullSession) GetApproved(tokenId *big.Int) (common.Address, error) {
|
|
return _IERC721Full.Contract.GetApproved(&_IERC721Full.CallOpts, tokenId)
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address operator)
|
|
func (_IERC721Full *IERC721FullCallerSession) GetApproved(tokenId *big.Int) (common.Address, error) {
|
|
return _IERC721Full.Contract.GetApproved(&_IERC721Full.CallOpts, tokenId)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_IERC721Full *IERC721FullCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error) {
|
|
var out []interface{}
|
|
err := _IERC721Full.contract.Call(opts, &out, "isApprovedForAll", owner, operator)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_IERC721Full *IERC721FullSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _IERC721Full.Contract.IsApprovedForAll(&_IERC721Full.CallOpts, owner, operator)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_IERC721Full *IERC721FullCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _IERC721Full.Contract.IsApprovedForAll(&_IERC721Full.CallOpts, owner, operator)
|
|
}
|
|
|
|
// Name is a free data retrieval call binding the contract method 0x06fdde03.
|
|
//
|
|
// Solidity: function name() view returns(string)
|
|
func (_IERC721Full *IERC721FullCaller) Name(opts *bind.CallOpts) (string, error) {
|
|
var out []interface{}
|
|
err := _IERC721Full.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 (_IERC721Full *IERC721FullSession) Name() (string, error) {
|
|
return _IERC721Full.Contract.Name(&_IERC721Full.CallOpts)
|
|
}
|
|
|
|
// Name is a free data retrieval call binding the contract method 0x06fdde03.
|
|
//
|
|
// Solidity: function name() view returns(string)
|
|
func (_IERC721Full *IERC721FullCallerSession) Name() (string, error) {
|
|
return _IERC721Full.Contract.Name(&_IERC721Full.CallOpts)
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address owner)
|
|
func (_IERC721Full *IERC721FullCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _IERC721Full.contract.Call(opts, &out, "ownerOf", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address owner)
|
|
func (_IERC721Full *IERC721FullSession) OwnerOf(tokenId *big.Int) (common.Address, error) {
|
|
return _IERC721Full.Contract.OwnerOf(&_IERC721Full.CallOpts, tokenId)
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address owner)
|
|
func (_IERC721Full *IERC721FullCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error) {
|
|
return _IERC721Full.Contract.OwnerOf(&_IERC721Full.CallOpts, tokenId)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_IERC721Full *IERC721FullCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _IERC721Full.contract.Call(opts, &out, "supportsInterface", interfaceId)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_IERC721Full *IERC721FullSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _IERC721Full.Contract.SupportsInterface(&_IERC721Full.CallOpts, interfaceId)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_IERC721Full *IERC721FullCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _IERC721Full.Contract.SupportsInterface(&_IERC721Full.CallOpts, interfaceId)
|
|
}
|
|
|
|
// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
|
|
//
|
|
// Solidity: function symbol() view returns(string)
|
|
func (_IERC721Full *IERC721FullCaller) Symbol(opts *bind.CallOpts) (string, error) {
|
|
var out []interface{}
|
|
err := _IERC721Full.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 (_IERC721Full *IERC721FullSession) Symbol() (string, error) {
|
|
return _IERC721Full.Contract.Symbol(&_IERC721Full.CallOpts)
|
|
}
|
|
|
|
// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
|
|
//
|
|
// Solidity: function symbol() view returns(string)
|
|
func (_IERC721Full *IERC721FullCallerSession) Symbol() (string, error) {
|
|
return _IERC721Full.Contract.Symbol(&_IERC721Full.CallOpts)
|
|
}
|
|
|
|
// TokenByIndex is a free data retrieval call binding the contract method 0x4f6ccce7.
|
|
//
|
|
// Solidity: function tokenByIndex(uint256 index) view returns(uint256)
|
|
func (_IERC721Full *IERC721FullCaller) TokenByIndex(opts *bind.CallOpts, index *big.Int) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _IERC721Full.contract.Call(opts, &out, "tokenByIndex", index)
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// TokenByIndex is a free data retrieval call binding the contract method 0x4f6ccce7.
|
|
//
|
|
// Solidity: function tokenByIndex(uint256 index) view returns(uint256)
|
|
func (_IERC721Full *IERC721FullSession) TokenByIndex(index *big.Int) (*big.Int, error) {
|
|
return _IERC721Full.Contract.TokenByIndex(&_IERC721Full.CallOpts, index)
|
|
}
|
|
|
|
// TokenByIndex is a free data retrieval call binding the contract method 0x4f6ccce7.
|
|
//
|
|
// Solidity: function tokenByIndex(uint256 index) view returns(uint256)
|
|
func (_IERC721Full *IERC721FullCallerSession) TokenByIndex(index *big.Int) (*big.Int, error) {
|
|
return _IERC721Full.Contract.TokenByIndex(&_IERC721Full.CallOpts, index)
|
|
}
|
|
|
|
// TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59.
|
|
//
|
|
// Solidity: function tokenOfOwnerByIndex(address owner, uint256 index) view returns(uint256 tokenId)
|
|
func (_IERC721Full *IERC721FullCaller) TokenOfOwnerByIndex(opts *bind.CallOpts, owner common.Address, index *big.Int) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _IERC721Full.contract.Call(opts, &out, "tokenOfOwnerByIndex", owner, index)
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59.
|
|
//
|
|
// Solidity: function tokenOfOwnerByIndex(address owner, uint256 index) view returns(uint256 tokenId)
|
|
func (_IERC721Full *IERC721FullSession) TokenOfOwnerByIndex(owner common.Address, index *big.Int) (*big.Int, error) {
|
|
return _IERC721Full.Contract.TokenOfOwnerByIndex(&_IERC721Full.CallOpts, owner, index)
|
|
}
|
|
|
|
// TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59.
|
|
//
|
|
// Solidity: function tokenOfOwnerByIndex(address owner, uint256 index) view returns(uint256 tokenId)
|
|
func (_IERC721Full *IERC721FullCallerSession) TokenOfOwnerByIndex(owner common.Address, index *big.Int) (*big.Int, error) {
|
|
return _IERC721Full.Contract.TokenOfOwnerByIndex(&_IERC721Full.CallOpts, owner, index)
|
|
}
|
|
|
|
// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd.
|
|
//
|
|
// Solidity: function tokenURI(uint256 tokenId) view returns(string)
|
|
func (_IERC721Full *IERC721FullCaller) TokenURI(opts *bind.CallOpts, tokenId *big.Int) (string, error) {
|
|
var out []interface{}
|
|
err := _IERC721Full.contract.Call(opts, &out, "tokenURI", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(string), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(string)).(*string)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd.
|
|
//
|
|
// Solidity: function tokenURI(uint256 tokenId) view returns(string)
|
|
func (_IERC721Full *IERC721FullSession) TokenURI(tokenId *big.Int) (string, error) {
|
|
return _IERC721Full.Contract.TokenURI(&_IERC721Full.CallOpts, tokenId)
|
|
}
|
|
|
|
// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd.
|
|
//
|
|
// Solidity: function tokenURI(uint256 tokenId) view returns(string)
|
|
func (_IERC721Full *IERC721FullCallerSession) TokenURI(tokenId *big.Int) (string, error) {
|
|
return _IERC721Full.Contract.TokenURI(&_IERC721Full.CallOpts, tokenId)
|
|
}
|
|
|
|
// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
|
|
//
|
|
// Solidity: function totalSupply() view returns(uint256)
|
|
func (_IERC721Full *IERC721FullCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _IERC721Full.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 (_IERC721Full *IERC721FullSession) TotalSupply() (*big.Int, error) {
|
|
return _IERC721Full.Contract.TotalSupply(&_IERC721Full.CallOpts)
|
|
}
|
|
|
|
// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
|
|
//
|
|
// Solidity: function totalSupply() view returns(uint256)
|
|
func (_IERC721Full *IERC721FullCallerSession) TotalSupply() (*big.Int, error) {
|
|
return _IERC721Full.Contract.TotalSupply(&_IERC721Full.CallOpts)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_IERC721Full *IERC721FullTransactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Full.contract.Transact(opts, "approve", to, tokenId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_IERC721Full *IERC721FullSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Full.Contract.Approve(&_IERC721Full.TransactOpts, to, tokenId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_IERC721Full *IERC721FullTransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Full.Contract.Approve(&_IERC721Full.TransactOpts, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721Full *IERC721FullTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Full.contract.Transact(opts, "safeTransferFrom", from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721Full *IERC721FullSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Full.Contract.SafeTransferFrom(&_IERC721Full.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721Full *IERC721FullTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Full.Contract.SafeTransferFrom(&_IERC721Full.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes data) returns()
|
|
func (_IERC721Full *IERC721FullTransactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error) {
|
|
return _IERC721Full.contract.Transact(opts, "safeTransferFrom0", from, to, tokenId, data)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes data) returns()
|
|
func (_IERC721Full *IERC721FullSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error) {
|
|
return _IERC721Full.Contract.SafeTransferFrom0(&_IERC721Full.TransactOpts, from, to, tokenId, data)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes data) returns()
|
|
func (_IERC721Full *IERC721FullTransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error) {
|
|
return _IERC721Full.Contract.SafeTransferFrom0(&_IERC721Full.TransactOpts, from, to, tokenId, data)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address operator, bool _approved) returns()
|
|
func (_IERC721Full *IERC721FullTransactor) SetApprovalForAll(opts *bind.TransactOpts, operator common.Address, _approved bool) (*types.Transaction, error) {
|
|
return _IERC721Full.contract.Transact(opts, "setApprovalForAll", operator, _approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address operator, bool _approved) returns()
|
|
func (_IERC721Full *IERC721FullSession) SetApprovalForAll(operator common.Address, _approved bool) (*types.Transaction, error) {
|
|
return _IERC721Full.Contract.SetApprovalForAll(&_IERC721Full.TransactOpts, operator, _approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address operator, bool _approved) returns()
|
|
func (_IERC721Full *IERC721FullTransactorSession) SetApprovalForAll(operator common.Address, _approved bool) (*types.Transaction, error) {
|
|
return _IERC721Full.Contract.SetApprovalForAll(&_IERC721Full.TransactOpts, operator, _approved)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721Full *IERC721FullTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Full.contract.Transact(opts, "transferFrom", from, to, tokenId)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721Full *IERC721FullSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Full.Contract.TransferFrom(&_IERC721Full.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721Full *IERC721FullTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Full.Contract.TransferFrom(&_IERC721Full.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// IERC721FullApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the IERC721Full contract.
|
|
type IERC721FullApprovalIterator struct {
|
|
Event *IERC721FullApproval // 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 *IERC721FullApprovalIterator) 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(IERC721FullApproval)
|
|
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(IERC721FullApproval)
|
|
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 *IERC721FullApprovalIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *IERC721FullApprovalIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// IERC721FullApproval represents a Approval event raised by the IERC721Full contract.
|
|
type IERC721FullApproval struct {
|
|
Owner common.Address
|
|
Approved common.Address
|
|
TokenId *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 approved, uint256 indexed tokenId)
|
|
func (_IERC721Full *IERC721FullFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, tokenId []*big.Int) (*IERC721FullApprovalIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var approvedRule []interface{}
|
|
for _, approvedItem := range approved {
|
|
approvedRule = append(approvedRule, approvedItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721Full.contract.FilterLogs(opts, "Approval", ownerRule, approvedRule, tokenIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721FullApprovalIterator{contract: _IERC721Full.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 approved, uint256 indexed tokenId)
|
|
func (_IERC721Full *IERC721FullFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC721FullApproval, owner []common.Address, approved []common.Address, tokenId []*big.Int) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var approvedRule []interface{}
|
|
for _, approvedItem := range approved {
|
|
approvedRule = append(approvedRule, approvedItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721Full.contract.WatchLogs(opts, "Approval", ownerRule, approvedRule, tokenIdRule)
|
|
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(IERC721FullApproval)
|
|
if err := _IERC721Full.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 approved, uint256 indexed tokenId)
|
|
func (_IERC721Full *IERC721FullFilterer) ParseApproval(log types.Log) (*IERC721FullApproval, error) {
|
|
event := new(IERC721FullApproval)
|
|
if err := _IERC721Full.contract.UnpackLog(event, "Approval", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// IERC721FullApprovalForAllIterator is returned from FilterApprovalForAll and is used to iterate over the raw logs and unpacked data for ApprovalForAll events raised by the IERC721Full contract.
|
|
type IERC721FullApprovalForAllIterator struct {
|
|
Event *IERC721FullApprovalForAll // 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 *IERC721FullApprovalForAllIterator) 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(IERC721FullApprovalForAll)
|
|
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(IERC721FullApprovalForAll)
|
|
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 *IERC721FullApprovalForAllIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *IERC721FullApprovalForAllIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// IERC721FullApprovalForAll represents a ApprovalForAll event raised by the IERC721Full contract.
|
|
type IERC721FullApprovalForAll struct {
|
|
Owner common.Address
|
|
Operator common.Address
|
|
Approved bool
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterApprovalForAll is a free log retrieval operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_IERC721Full *IERC721FullFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*IERC721FullApprovalForAllIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721Full.contract.FilterLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721FullApprovalForAllIterator{contract: _IERC721Full.contract, event: "ApprovalForAll", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchApprovalForAll is a free log subscription operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_IERC721Full *IERC721FullFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *IERC721FullApprovalForAll, owner []common.Address, operator []common.Address) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721Full.contract.WatchLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
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(IERC721FullApprovalForAll)
|
|
if err := _IERC721Full.contract.UnpackLog(event, "ApprovalForAll", 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
|
|
}
|
|
|
|
// ParseApprovalForAll is a log parse operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_IERC721Full *IERC721FullFilterer) ParseApprovalForAll(log types.Log) (*IERC721FullApprovalForAll, error) {
|
|
event := new(IERC721FullApprovalForAll)
|
|
if err := _IERC721Full.contract.UnpackLog(event, "ApprovalForAll", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// IERC721FullTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the IERC721Full contract.
|
|
type IERC721FullTransferIterator struct {
|
|
Event *IERC721FullTransfer // 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 *IERC721FullTransferIterator) 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(IERC721FullTransfer)
|
|
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(IERC721FullTransfer)
|
|
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 *IERC721FullTransferIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *IERC721FullTransferIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// IERC721FullTransfer represents a Transfer event raised by the IERC721Full contract.
|
|
type IERC721FullTransfer struct {
|
|
From common.Address
|
|
To common.Address
|
|
TokenId *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 indexed tokenId)
|
|
func (_IERC721Full *IERC721FullFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, tokenId []*big.Int) (*IERC721FullTransferIterator, error) {
|
|
|
|
var fromRule []interface{}
|
|
for _, fromItem := range from {
|
|
fromRule = append(fromRule, fromItem)
|
|
}
|
|
var toRule []interface{}
|
|
for _, toItem := range to {
|
|
toRule = append(toRule, toItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721Full.contract.FilterLogs(opts, "Transfer", fromRule, toRule, tokenIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721FullTransferIterator{contract: _IERC721Full.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 indexed tokenId)
|
|
func (_IERC721Full *IERC721FullFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC721FullTransfer, from []common.Address, to []common.Address, tokenId []*big.Int) (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)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721Full.contract.WatchLogs(opts, "Transfer", fromRule, toRule, tokenIdRule)
|
|
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(IERC721FullTransfer)
|
|
if err := _IERC721Full.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 indexed tokenId)
|
|
func (_IERC721Full *IERC721FullFilterer) ParseTransfer(log types.Log) (*IERC721FullTransfer, error) {
|
|
event := new(IERC721FullTransfer)
|
|
if err := _IERC721Full.contract.UnpackLog(event, "Transfer", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// IERC721MetadataABI is the input ABI used to generate the binding from.
|
|
const IERC721MetadataABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"getApproved\",\"outputs\":[{\"name\":\"operator\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"ownerOf\",\"outputs\":[{\"name\":\"owner\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"balance\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"operator\",\"type\":\"address\"},{\"name\":\"_approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"tokenURI\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"approved\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"}]"
|
|
|
|
// IERC721MetadataFuncSigs maps the 4-byte function signature to its string representation.
|
|
var IERC721MetadataFuncSigs = map[string]string{
|
|
"095ea7b3": "approve(address,uint256)",
|
|
"70a08231": "balanceOf(address)",
|
|
"081812fc": "getApproved(uint256)",
|
|
"e985e9c5": "isApprovedForAll(address,address)",
|
|
"06fdde03": "name()",
|
|
"6352211e": "ownerOf(uint256)",
|
|
"42842e0e": "safeTransferFrom(address,address,uint256)",
|
|
"b88d4fde": "safeTransferFrom(address,address,uint256,bytes)",
|
|
"a22cb465": "setApprovalForAll(address,bool)",
|
|
"01ffc9a7": "supportsInterface(bytes4)",
|
|
"95d89b41": "symbol()",
|
|
"c87b56dd": "tokenURI(uint256)",
|
|
"23b872dd": "transferFrom(address,address,uint256)",
|
|
}
|
|
|
|
// IERC721Metadata is an auto generated Go binding around an Ethereum contract.
|
|
type IERC721Metadata struct {
|
|
IERC721MetadataCaller // Read-only binding to the contract
|
|
IERC721MetadataTransactor // Write-only binding to the contract
|
|
IERC721MetadataFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// IERC721MetadataCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type IERC721MetadataCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// IERC721MetadataTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type IERC721MetadataTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// IERC721MetadataFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type IERC721MetadataFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// IERC721MetadataSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type IERC721MetadataSession struct {
|
|
Contract *IERC721Metadata // 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
|
|
}
|
|
|
|
// IERC721MetadataCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type IERC721MetadataCallerSession struct {
|
|
Contract *IERC721MetadataCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// IERC721MetadataTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type IERC721MetadataTransactorSession struct {
|
|
Contract *IERC721MetadataTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// IERC721MetadataRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type IERC721MetadataRaw struct {
|
|
Contract *IERC721Metadata // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// IERC721MetadataCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type IERC721MetadataCallerRaw struct {
|
|
Contract *IERC721MetadataCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// IERC721MetadataTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type IERC721MetadataTransactorRaw struct {
|
|
Contract *IERC721MetadataTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewIERC721Metadata creates a new instance of IERC721Metadata, bound to a specific deployed contract.
|
|
func NewIERC721Metadata(address common.Address, backend bind.ContractBackend) (*IERC721Metadata, error) {
|
|
contract, err := bindIERC721Metadata(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721Metadata{IERC721MetadataCaller: IERC721MetadataCaller{contract: contract}, IERC721MetadataTransactor: IERC721MetadataTransactor{contract: contract}, IERC721MetadataFilterer: IERC721MetadataFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewIERC721MetadataCaller creates a new read-only instance of IERC721Metadata, bound to a specific deployed contract.
|
|
func NewIERC721MetadataCaller(address common.Address, caller bind.ContractCaller) (*IERC721MetadataCaller, error) {
|
|
contract, err := bindIERC721Metadata(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721MetadataCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewIERC721MetadataTransactor creates a new write-only instance of IERC721Metadata, bound to a specific deployed contract.
|
|
func NewIERC721MetadataTransactor(address common.Address, transactor bind.ContractTransactor) (*IERC721MetadataTransactor, error) {
|
|
contract, err := bindIERC721Metadata(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721MetadataTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewIERC721MetadataFilterer creates a new log filterer instance of IERC721Metadata, bound to a specific deployed contract.
|
|
func NewIERC721MetadataFilterer(address common.Address, filterer bind.ContractFilterer) (*IERC721MetadataFilterer, error) {
|
|
contract, err := bindIERC721Metadata(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721MetadataFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindIERC721Metadata binds a generic wrapper to an already deployed contract.
|
|
func bindIERC721Metadata(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(IERC721MetadataABI))
|
|
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 (_IERC721Metadata *IERC721MetadataRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _IERC721Metadata.Contract.IERC721MetadataCaller.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 (_IERC721Metadata *IERC721MetadataRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _IERC721Metadata.Contract.IERC721MetadataTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_IERC721Metadata *IERC721MetadataRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _IERC721Metadata.Contract.IERC721MetadataTransactor.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 (_IERC721Metadata *IERC721MetadataCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _IERC721Metadata.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 (_IERC721Metadata *IERC721MetadataTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _IERC721Metadata.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_IERC721Metadata *IERC721MetadataTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _IERC721Metadata.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address owner) view returns(uint256 balance)
|
|
func (_IERC721Metadata *IERC721MetadataCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _IERC721Metadata.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 balance)
|
|
func (_IERC721Metadata *IERC721MetadataSession) BalanceOf(owner common.Address) (*big.Int, error) {
|
|
return _IERC721Metadata.Contract.BalanceOf(&_IERC721Metadata.CallOpts, owner)
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address owner) view returns(uint256 balance)
|
|
func (_IERC721Metadata *IERC721MetadataCallerSession) BalanceOf(owner common.Address) (*big.Int, error) {
|
|
return _IERC721Metadata.Contract.BalanceOf(&_IERC721Metadata.CallOpts, owner)
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address operator)
|
|
func (_IERC721Metadata *IERC721MetadataCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _IERC721Metadata.contract.Call(opts, &out, "getApproved", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address operator)
|
|
func (_IERC721Metadata *IERC721MetadataSession) GetApproved(tokenId *big.Int) (common.Address, error) {
|
|
return _IERC721Metadata.Contract.GetApproved(&_IERC721Metadata.CallOpts, tokenId)
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address operator)
|
|
func (_IERC721Metadata *IERC721MetadataCallerSession) GetApproved(tokenId *big.Int) (common.Address, error) {
|
|
return _IERC721Metadata.Contract.GetApproved(&_IERC721Metadata.CallOpts, tokenId)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_IERC721Metadata *IERC721MetadataCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error) {
|
|
var out []interface{}
|
|
err := _IERC721Metadata.contract.Call(opts, &out, "isApprovedForAll", owner, operator)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_IERC721Metadata *IERC721MetadataSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _IERC721Metadata.Contract.IsApprovedForAll(&_IERC721Metadata.CallOpts, owner, operator)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_IERC721Metadata *IERC721MetadataCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _IERC721Metadata.Contract.IsApprovedForAll(&_IERC721Metadata.CallOpts, owner, operator)
|
|
}
|
|
|
|
// Name is a free data retrieval call binding the contract method 0x06fdde03.
|
|
//
|
|
// Solidity: function name() view returns(string)
|
|
func (_IERC721Metadata *IERC721MetadataCaller) Name(opts *bind.CallOpts) (string, error) {
|
|
var out []interface{}
|
|
err := _IERC721Metadata.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 (_IERC721Metadata *IERC721MetadataSession) Name() (string, error) {
|
|
return _IERC721Metadata.Contract.Name(&_IERC721Metadata.CallOpts)
|
|
}
|
|
|
|
// Name is a free data retrieval call binding the contract method 0x06fdde03.
|
|
//
|
|
// Solidity: function name() view returns(string)
|
|
func (_IERC721Metadata *IERC721MetadataCallerSession) Name() (string, error) {
|
|
return _IERC721Metadata.Contract.Name(&_IERC721Metadata.CallOpts)
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address owner)
|
|
func (_IERC721Metadata *IERC721MetadataCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _IERC721Metadata.contract.Call(opts, &out, "ownerOf", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address owner)
|
|
func (_IERC721Metadata *IERC721MetadataSession) OwnerOf(tokenId *big.Int) (common.Address, error) {
|
|
return _IERC721Metadata.Contract.OwnerOf(&_IERC721Metadata.CallOpts, tokenId)
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address owner)
|
|
func (_IERC721Metadata *IERC721MetadataCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error) {
|
|
return _IERC721Metadata.Contract.OwnerOf(&_IERC721Metadata.CallOpts, tokenId)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_IERC721Metadata *IERC721MetadataCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _IERC721Metadata.contract.Call(opts, &out, "supportsInterface", interfaceId)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_IERC721Metadata *IERC721MetadataSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _IERC721Metadata.Contract.SupportsInterface(&_IERC721Metadata.CallOpts, interfaceId)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_IERC721Metadata *IERC721MetadataCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _IERC721Metadata.Contract.SupportsInterface(&_IERC721Metadata.CallOpts, interfaceId)
|
|
}
|
|
|
|
// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
|
|
//
|
|
// Solidity: function symbol() view returns(string)
|
|
func (_IERC721Metadata *IERC721MetadataCaller) Symbol(opts *bind.CallOpts) (string, error) {
|
|
var out []interface{}
|
|
err := _IERC721Metadata.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 (_IERC721Metadata *IERC721MetadataSession) Symbol() (string, error) {
|
|
return _IERC721Metadata.Contract.Symbol(&_IERC721Metadata.CallOpts)
|
|
}
|
|
|
|
// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
|
|
//
|
|
// Solidity: function symbol() view returns(string)
|
|
func (_IERC721Metadata *IERC721MetadataCallerSession) Symbol() (string, error) {
|
|
return _IERC721Metadata.Contract.Symbol(&_IERC721Metadata.CallOpts)
|
|
}
|
|
|
|
// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd.
|
|
//
|
|
// Solidity: function tokenURI(uint256 tokenId) view returns(string)
|
|
func (_IERC721Metadata *IERC721MetadataCaller) TokenURI(opts *bind.CallOpts, tokenId *big.Int) (string, error) {
|
|
var out []interface{}
|
|
err := _IERC721Metadata.contract.Call(opts, &out, "tokenURI", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(string), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(string)).(*string)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd.
|
|
//
|
|
// Solidity: function tokenURI(uint256 tokenId) view returns(string)
|
|
func (_IERC721Metadata *IERC721MetadataSession) TokenURI(tokenId *big.Int) (string, error) {
|
|
return _IERC721Metadata.Contract.TokenURI(&_IERC721Metadata.CallOpts, tokenId)
|
|
}
|
|
|
|
// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd.
|
|
//
|
|
// Solidity: function tokenURI(uint256 tokenId) view returns(string)
|
|
func (_IERC721Metadata *IERC721MetadataCallerSession) TokenURI(tokenId *big.Int) (string, error) {
|
|
return _IERC721Metadata.Contract.TokenURI(&_IERC721Metadata.CallOpts, tokenId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_IERC721Metadata *IERC721MetadataTransactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Metadata.contract.Transact(opts, "approve", to, tokenId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_IERC721Metadata *IERC721MetadataSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Metadata.Contract.Approve(&_IERC721Metadata.TransactOpts, to, tokenId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_IERC721Metadata *IERC721MetadataTransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Metadata.Contract.Approve(&_IERC721Metadata.TransactOpts, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721Metadata *IERC721MetadataTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Metadata.contract.Transact(opts, "safeTransferFrom", from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721Metadata *IERC721MetadataSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Metadata.Contract.SafeTransferFrom(&_IERC721Metadata.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721Metadata *IERC721MetadataTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Metadata.Contract.SafeTransferFrom(&_IERC721Metadata.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes data) returns()
|
|
func (_IERC721Metadata *IERC721MetadataTransactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error) {
|
|
return _IERC721Metadata.contract.Transact(opts, "safeTransferFrom0", from, to, tokenId, data)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes data) returns()
|
|
func (_IERC721Metadata *IERC721MetadataSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error) {
|
|
return _IERC721Metadata.Contract.SafeTransferFrom0(&_IERC721Metadata.TransactOpts, from, to, tokenId, data)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes data) returns()
|
|
func (_IERC721Metadata *IERC721MetadataTransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error) {
|
|
return _IERC721Metadata.Contract.SafeTransferFrom0(&_IERC721Metadata.TransactOpts, from, to, tokenId, data)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address operator, bool _approved) returns()
|
|
func (_IERC721Metadata *IERC721MetadataTransactor) SetApprovalForAll(opts *bind.TransactOpts, operator common.Address, _approved bool) (*types.Transaction, error) {
|
|
return _IERC721Metadata.contract.Transact(opts, "setApprovalForAll", operator, _approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address operator, bool _approved) returns()
|
|
func (_IERC721Metadata *IERC721MetadataSession) SetApprovalForAll(operator common.Address, _approved bool) (*types.Transaction, error) {
|
|
return _IERC721Metadata.Contract.SetApprovalForAll(&_IERC721Metadata.TransactOpts, operator, _approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address operator, bool _approved) returns()
|
|
func (_IERC721Metadata *IERC721MetadataTransactorSession) SetApprovalForAll(operator common.Address, _approved bool) (*types.Transaction, error) {
|
|
return _IERC721Metadata.Contract.SetApprovalForAll(&_IERC721Metadata.TransactOpts, operator, _approved)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721Metadata *IERC721MetadataTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Metadata.contract.Transact(opts, "transferFrom", from, to, tokenId)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721Metadata *IERC721MetadataSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Metadata.Contract.TransferFrom(&_IERC721Metadata.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_IERC721Metadata *IERC721MetadataTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _IERC721Metadata.Contract.TransferFrom(&_IERC721Metadata.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// IERC721MetadataApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the IERC721Metadata contract.
|
|
type IERC721MetadataApprovalIterator struct {
|
|
Event *IERC721MetadataApproval // 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 *IERC721MetadataApprovalIterator) 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(IERC721MetadataApproval)
|
|
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(IERC721MetadataApproval)
|
|
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 *IERC721MetadataApprovalIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *IERC721MetadataApprovalIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// IERC721MetadataApproval represents a Approval event raised by the IERC721Metadata contract.
|
|
type IERC721MetadataApproval struct {
|
|
Owner common.Address
|
|
Approved common.Address
|
|
TokenId *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 approved, uint256 indexed tokenId)
|
|
func (_IERC721Metadata *IERC721MetadataFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, tokenId []*big.Int) (*IERC721MetadataApprovalIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var approvedRule []interface{}
|
|
for _, approvedItem := range approved {
|
|
approvedRule = append(approvedRule, approvedItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721Metadata.contract.FilterLogs(opts, "Approval", ownerRule, approvedRule, tokenIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721MetadataApprovalIterator{contract: _IERC721Metadata.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 approved, uint256 indexed tokenId)
|
|
func (_IERC721Metadata *IERC721MetadataFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC721MetadataApproval, owner []common.Address, approved []common.Address, tokenId []*big.Int) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var approvedRule []interface{}
|
|
for _, approvedItem := range approved {
|
|
approvedRule = append(approvedRule, approvedItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721Metadata.contract.WatchLogs(opts, "Approval", ownerRule, approvedRule, tokenIdRule)
|
|
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(IERC721MetadataApproval)
|
|
if err := _IERC721Metadata.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 approved, uint256 indexed tokenId)
|
|
func (_IERC721Metadata *IERC721MetadataFilterer) ParseApproval(log types.Log) (*IERC721MetadataApproval, error) {
|
|
event := new(IERC721MetadataApproval)
|
|
if err := _IERC721Metadata.contract.UnpackLog(event, "Approval", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// IERC721MetadataApprovalForAllIterator is returned from FilterApprovalForAll and is used to iterate over the raw logs and unpacked data for ApprovalForAll events raised by the IERC721Metadata contract.
|
|
type IERC721MetadataApprovalForAllIterator struct {
|
|
Event *IERC721MetadataApprovalForAll // 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 *IERC721MetadataApprovalForAllIterator) 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(IERC721MetadataApprovalForAll)
|
|
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(IERC721MetadataApprovalForAll)
|
|
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 *IERC721MetadataApprovalForAllIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *IERC721MetadataApprovalForAllIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// IERC721MetadataApprovalForAll represents a ApprovalForAll event raised by the IERC721Metadata contract.
|
|
type IERC721MetadataApprovalForAll struct {
|
|
Owner common.Address
|
|
Operator common.Address
|
|
Approved bool
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterApprovalForAll is a free log retrieval operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_IERC721Metadata *IERC721MetadataFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*IERC721MetadataApprovalForAllIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721Metadata.contract.FilterLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721MetadataApprovalForAllIterator{contract: _IERC721Metadata.contract, event: "ApprovalForAll", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchApprovalForAll is a free log subscription operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_IERC721Metadata *IERC721MetadataFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *IERC721MetadataApprovalForAll, owner []common.Address, operator []common.Address) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721Metadata.contract.WatchLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
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(IERC721MetadataApprovalForAll)
|
|
if err := _IERC721Metadata.contract.UnpackLog(event, "ApprovalForAll", 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
|
|
}
|
|
|
|
// ParseApprovalForAll is a log parse operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_IERC721Metadata *IERC721MetadataFilterer) ParseApprovalForAll(log types.Log) (*IERC721MetadataApprovalForAll, error) {
|
|
event := new(IERC721MetadataApprovalForAll)
|
|
if err := _IERC721Metadata.contract.UnpackLog(event, "ApprovalForAll", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// IERC721MetadataTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the IERC721Metadata contract.
|
|
type IERC721MetadataTransferIterator struct {
|
|
Event *IERC721MetadataTransfer // 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 *IERC721MetadataTransferIterator) 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(IERC721MetadataTransfer)
|
|
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(IERC721MetadataTransfer)
|
|
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 *IERC721MetadataTransferIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *IERC721MetadataTransferIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// IERC721MetadataTransfer represents a Transfer event raised by the IERC721Metadata contract.
|
|
type IERC721MetadataTransfer struct {
|
|
From common.Address
|
|
To common.Address
|
|
TokenId *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 indexed tokenId)
|
|
func (_IERC721Metadata *IERC721MetadataFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, tokenId []*big.Int) (*IERC721MetadataTransferIterator, error) {
|
|
|
|
var fromRule []interface{}
|
|
for _, fromItem := range from {
|
|
fromRule = append(fromRule, fromItem)
|
|
}
|
|
var toRule []interface{}
|
|
for _, toItem := range to {
|
|
toRule = append(toRule, toItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721Metadata.contract.FilterLogs(opts, "Transfer", fromRule, toRule, tokenIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721MetadataTransferIterator{contract: _IERC721Metadata.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 indexed tokenId)
|
|
func (_IERC721Metadata *IERC721MetadataFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC721MetadataTransfer, from []common.Address, to []common.Address, tokenId []*big.Int) (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)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _IERC721Metadata.contract.WatchLogs(opts, "Transfer", fromRule, toRule, tokenIdRule)
|
|
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(IERC721MetadataTransfer)
|
|
if err := _IERC721Metadata.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 indexed tokenId)
|
|
func (_IERC721Metadata *IERC721MetadataFilterer) ParseTransfer(log types.Log) (*IERC721MetadataTransfer, error) {
|
|
event := new(IERC721MetadataTransfer)
|
|
if err := _IERC721Metadata.contract.UnpackLog(event, "Transfer", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// IERC721ReceiverABI is the input ABI used to generate the binding from.
|
|
const IERC721ReceiverABI = "[{\"constant\":false,\"inputs\":[{\"name\":\"operator\",\"type\":\"address\"},{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"onERC721Received\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes4\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"
|
|
|
|
// IERC721ReceiverFuncSigs maps the 4-byte function signature to its string representation.
|
|
var IERC721ReceiverFuncSigs = map[string]string{
|
|
"150b7a02": "onERC721Received(address,address,uint256,bytes)",
|
|
}
|
|
|
|
// IERC721Receiver is an auto generated Go binding around an Ethereum contract.
|
|
type IERC721Receiver struct {
|
|
IERC721ReceiverCaller // Read-only binding to the contract
|
|
IERC721ReceiverTransactor // Write-only binding to the contract
|
|
IERC721ReceiverFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// IERC721ReceiverCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type IERC721ReceiverCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// IERC721ReceiverTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type IERC721ReceiverTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// IERC721ReceiverFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type IERC721ReceiverFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// IERC721ReceiverSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type IERC721ReceiverSession struct {
|
|
Contract *IERC721Receiver // 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
|
|
}
|
|
|
|
// IERC721ReceiverCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type IERC721ReceiverCallerSession struct {
|
|
Contract *IERC721ReceiverCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// IERC721ReceiverTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type IERC721ReceiverTransactorSession struct {
|
|
Contract *IERC721ReceiverTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// IERC721ReceiverRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type IERC721ReceiverRaw struct {
|
|
Contract *IERC721Receiver // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// IERC721ReceiverCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type IERC721ReceiverCallerRaw struct {
|
|
Contract *IERC721ReceiverCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// IERC721ReceiverTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type IERC721ReceiverTransactorRaw struct {
|
|
Contract *IERC721ReceiverTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewIERC721Receiver creates a new instance of IERC721Receiver, bound to a specific deployed contract.
|
|
func NewIERC721Receiver(address common.Address, backend bind.ContractBackend) (*IERC721Receiver, error) {
|
|
contract, err := bindIERC721Receiver(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721Receiver{IERC721ReceiverCaller: IERC721ReceiverCaller{contract: contract}, IERC721ReceiverTransactor: IERC721ReceiverTransactor{contract: contract}, IERC721ReceiverFilterer: IERC721ReceiverFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewIERC721ReceiverCaller creates a new read-only instance of IERC721Receiver, bound to a specific deployed contract.
|
|
func NewIERC721ReceiverCaller(address common.Address, caller bind.ContractCaller) (*IERC721ReceiverCaller, error) {
|
|
contract, err := bindIERC721Receiver(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721ReceiverCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewIERC721ReceiverTransactor creates a new write-only instance of IERC721Receiver, bound to a specific deployed contract.
|
|
func NewIERC721ReceiverTransactor(address common.Address, transactor bind.ContractTransactor) (*IERC721ReceiverTransactor, error) {
|
|
contract, err := bindIERC721Receiver(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721ReceiverTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewIERC721ReceiverFilterer creates a new log filterer instance of IERC721Receiver, bound to a specific deployed contract.
|
|
func NewIERC721ReceiverFilterer(address common.Address, filterer bind.ContractFilterer) (*IERC721ReceiverFilterer, error) {
|
|
contract, err := bindIERC721Receiver(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &IERC721ReceiverFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindIERC721Receiver binds a generic wrapper to an already deployed contract.
|
|
func bindIERC721Receiver(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(IERC721ReceiverABI))
|
|
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 (_IERC721Receiver *IERC721ReceiverRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _IERC721Receiver.Contract.IERC721ReceiverCaller.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 (_IERC721Receiver *IERC721ReceiverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _IERC721Receiver.Contract.IERC721ReceiverTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_IERC721Receiver *IERC721ReceiverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _IERC721Receiver.Contract.IERC721ReceiverTransactor.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 (_IERC721Receiver *IERC721ReceiverCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _IERC721Receiver.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 (_IERC721Receiver *IERC721ReceiverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _IERC721Receiver.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_IERC721Receiver *IERC721ReceiverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _IERC721Receiver.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// OnERC721Received is a paid mutator transaction binding the contract method 0x150b7a02.
|
|
//
|
|
// Solidity: function onERC721Received(address operator, address from, uint256 tokenId, bytes data) returns(bytes4)
|
|
func (_IERC721Receiver *IERC721ReceiverTransactor) OnERC721Received(opts *bind.TransactOpts, operator common.Address, from common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error) {
|
|
return _IERC721Receiver.contract.Transact(opts, "onERC721Received", operator, from, tokenId, data)
|
|
}
|
|
|
|
// OnERC721Received is a paid mutator transaction binding the contract method 0x150b7a02.
|
|
//
|
|
// Solidity: function onERC721Received(address operator, address from, uint256 tokenId, bytes data) returns(bytes4)
|
|
func (_IERC721Receiver *IERC721ReceiverSession) OnERC721Received(operator common.Address, from common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error) {
|
|
return _IERC721Receiver.Contract.OnERC721Received(&_IERC721Receiver.TransactOpts, operator, from, tokenId, data)
|
|
}
|
|
|
|
// OnERC721Received is a paid mutator transaction binding the contract method 0x150b7a02.
|
|
//
|
|
// Solidity: function onERC721Received(address operator, address from, uint256 tokenId, bytes data) returns(bytes4)
|
|
func (_IERC721Receiver *IERC721ReceiverTransactorSession) OnERC721Received(operator common.Address, from common.Address, tokenId *big.Int, data []byte) (*types.Transaction, error) {
|
|
return _IERC721Receiver.Contract.OnERC721Received(&_IERC721Receiver.TransactOpts, operator, from, tokenId, data)
|
|
}
|
|
|
|
// StickerMarketABI is the input ABI used to generate the binding from.
|
|
const StickerMarketABI = "[{\"constant\":false,\"inputs\":[{\"name\":\"_packId\",\"type\":\"uint256\"},{\"name\":\"_limit\",\"type\":\"uint256\"}],\"name\":\"purgePack\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"snt\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"stickerType\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\"},{\"name\":\"_packId\",\"type\":\"uint256\"}],\"name\":\"generateToken\",\"outputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"setBurnRate\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_price\",\"type\":\"uint256\"},{\"name\":\"_donate\",\"type\":\"uint256\"},{\"name\":\"_category\",\"type\":\"bytes4[]\"},{\"name\":\"_owner\",\"type\":\"address\"},{\"name\":\"_contenthash\",\"type\":\"bytes\"},{\"name\":\"_fee\",\"type\":\"uint256\"}],\"name\":\"registerPack\",\"outputs\":[{\"name\":\"packId\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_newController\",\"type\":\"address\"}],\"name\":\"changeController\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"stickerPack\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_price\",\"type\":\"uint256\"},{\"name\":\"_donate\",\"type\":\"uint256\"},{\"name\":\"_category\",\"type\":\"bytes4[]\"},{\"name\":\"_owner\",\"type\":\"address\"},{\"name\":\"_contenthash\",\"type\":\"bytes\"}],\"name\":\"generatePack\",\"outputs\":[{\"name\":\"packId\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_state\",\"type\":\"uint8\"}],\"name\":\"setMarketState\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_from\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"},{\"name\":\"_token\",\"type\":\"address\"},{\"name\":\"_data\",\"type\":\"bytes\"}],\"name\":\"receiveApproval\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"setRegisterFee\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"getTokenData\",\"outputs\":[{\"name\":\"category\",\"type\":\"bytes4[]\"},{\"name\":\"timestamp\",\"type\":\"uint256\"},{\"name\":\"contenthash\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"state\",\"outputs\":[{\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_newController\",\"type\":\"address\"}],\"name\":\"migrate\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_token\",\"type\":\"address\"}],\"name\":\"claimTokens\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_packId\",\"type\":\"uint256\"},{\"name\":\"_destination\",\"type\":\"address\"},{\"name\":\"_price\",\"type\":\"uint256\"}],\"name\":\"buyToken\",\"outputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"controller\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"_token\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"_controller\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"ClaimedTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"state\",\"type\":\"uint8\"}],\"name\":\"MarketState\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"RegisterFee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"BurnRate\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"packId\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"dataPrice\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"contenthash\",\"type\":\"bytes\"}],\"name\":\"Register\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"controller\",\"type\":\"address\"}],\"name\":\"NewController\",\"type\":\"event\"}]"
|
|
|
|
// StickerMarketFuncSigs maps the 4-byte function signature to its string representation.
|
|
var StickerMarketFuncSigs = map[string]string{
|
|
"f3e62640": "buyToken(uint256,address,uint256)",
|
|
"3cebb823": "changeController(address)",
|
|
"df8de3e7": "claimTokens(address)",
|
|
"f77c4791": "controller()",
|
|
"4c06dc17": "generatePack(uint256,uint256,bytes4[],address,bytes)",
|
|
"188b5372": "generateToken(address,uint256)",
|
|
"b09afec1": "getTokenData(uint256)",
|
|
"ce5494bb": "migrate(address)",
|
|
"00b3c91b": "purgePack(uint256,uint256)",
|
|
"8f4ffcb1": "receiveApproval(address,uint256,address,bytes)",
|
|
"1cf75710": "registerPack(uint256,uint256,bytes4[],address,bytes,uint256)",
|
|
"189d165e": "setBurnRate(uint256)",
|
|
"536b0445": "setMarketState(uint8)",
|
|
"92be2ab8": "setRegisterFee(uint256)",
|
|
"060eb520": "snt()",
|
|
"c19d93fb": "state()",
|
|
"4858b015": "stickerPack()",
|
|
"0ddd4c87": "stickerType()",
|
|
}
|
|
|
|
// StickerMarket is an auto generated Go binding around an Ethereum contract.
|
|
type StickerMarket struct {
|
|
StickerMarketCaller // Read-only binding to the contract
|
|
StickerMarketTransactor // Write-only binding to the contract
|
|
StickerMarketFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// StickerMarketCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type StickerMarketCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// StickerMarketTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type StickerMarketTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// StickerMarketFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type StickerMarketFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// StickerMarketSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type StickerMarketSession struct {
|
|
Contract *StickerMarket // 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
|
|
}
|
|
|
|
// StickerMarketCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type StickerMarketCallerSession struct {
|
|
Contract *StickerMarketCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// StickerMarketTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type StickerMarketTransactorSession struct {
|
|
Contract *StickerMarketTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// StickerMarketRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type StickerMarketRaw struct {
|
|
Contract *StickerMarket // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// StickerMarketCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type StickerMarketCallerRaw struct {
|
|
Contract *StickerMarketCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// StickerMarketTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type StickerMarketTransactorRaw struct {
|
|
Contract *StickerMarketTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewStickerMarket creates a new instance of StickerMarket, bound to a specific deployed contract.
|
|
func NewStickerMarket(address common.Address, backend bind.ContractBackend) (*StickerMarket, error) {
|
|
contract, err := bindStickerMarket(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerMarket{StickerMarketCaller: StickerMarketCaller{contract: contract}, StickerMarketTransactor: StickerMarketTransactor{contract: contract}, StickerMarketFilterer: StickerMarketFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewStickerMarketCaller creates a new read-only instance of StickerMarket, bound to a specific deployed contract.
|
|
func NewStickerMarketCaller(address common.Address, caller bind.ContractCaller) (*StickerMarketCaller, error) {
|
|
contract, err := bindStickerMarket(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerMarketCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewStickerMarketTransactor creates a new write-only instance of StickerMarket, bound to a specific deployed contract.
|
|
func NewStickerMarketTransactor(address common.Address, transactor bind.ContractTransactor) (*StickerMarketTransactor, error) {
|
|
contract, err := bindStickerMarket(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerMarketTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewStickerMarketFilterer creates a new log filterer instance of StickerMarket, bound to a specific deployed contract.
|
|
func NewStickerMarketFilterer(address common.Address, filterer bind.ContractFilterer) (*StickerMarketFilterer, error) {
|
|
contract, err := bindStickerMarket(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerMarketFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindStickerMarket binds a generic wrapper to an already deployed contract.
|
|
func bindStickerMarket(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(StickerMarketABI))
|
|
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 (_StickerMarket *StickerMarketRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _StickerMarket.Contract.StickerMarketCaller.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 (_StickerMarket *StickerMarketRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.StickerMarketTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_StickerMarket *StickerMarketRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.StickerMarketTransactor.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 (_StickerMarket *StickerMarketCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _StickerMarket.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 (_StickerMarket *StickerMarketTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_StickerMarket *StickerMarketTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// Controller is a free data retrieval call binding the contract method 0xf77c4791.
|
|
//
|
|
// Solidity: function controller() view returns(address)
|
|
func (_StickerMarket *StickerMarketCaller) Controller(opts *bind.CallOpts) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _StickerMarket.contract.Call(opts, &out, "controller")
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Controller is a free data retrieval call binding the contract method 0xf77c4791.
|
|
//
|
|
// Solidity: function controller() view returns(address)
|
|
func (_StickerMarket *StickerMarketSession) Controller() (common.Address, error) {
|
|
return _StickerMarket.Contract.Controller(&_StickerMarket.CallOpts)
|
|
}
|
|
|
|
// Controller is a free data retrieval call binding the contract method 0xf77c4791.
|
|
//
|
|
// Solidity: function controller() view returns(address)
|
|
func (_StickerMarket *StickerMarketCallerSession) Controller() (common.Address, error) {
|
|
return _StickerMarket.Contract.Controller(&_StickerMarket.CallOpts)
|
|
}
|
|
|
|
// GetTokenData is a free data retrieval call binding the contract method 0xb09afec1.
|
|
//
|
|
// Solidity: function getTokenData(uint256 _tokenId) view returns(bytes4[] category, uint256 timestamp, bytes contenthash)
|
|
func (_StickerMarket *StickerMarketCaller) GetTokenData(opts *bind.CallOpts, _tokenId *big.Int) (struct {
|
|
Category [][4]byte
|
|
Timestamp *big.Int
|
|
Contenthash []byte
|
|
}, error) {
|
|
var out []interface{}
|
|
err := _StickerMarket.contract.Call(opts, &out, "getTokenData", _tokenId)
|
|
|
|
outstruct := new(struct {
|
|
Category [][4]byte
|
|
Timestamp *big.Int
|
|
Contenthash []byte
|
|
})
|
|
if err != nil {
|
|
return *outstruct, err
|
|
}
|
|
|
|
outstruct.Category = *abi.ConvertType(out[0], new([][4]byte)).(*[][4]byte)
|
|
outstruct.Timestamp = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int)
|
|
outstruct.Contenthash = *abi.ConvertType(out[2], new([]byte)).(*[]byte)
|
|
|
|
return *outstruct, err
|
|
|
|
}
|
|
|
|
// GetTokenData is a free data retrieval call binding the contract method 0xb09afec1.
|
|
//
|
|
// Solidity: function getTokenData(uint256 _tokenId) view returns(bytes4[] category, uint256 timestamp, bytes contenthash)
|
|
func (_StickerMarket *StickerMarketSession) GetTokenData(_tokenId *big.Int) (struct {
|
|
Category [][4]byte
|
|
Timestamp *big.Int
|
|
Contenthash []byte
|
|
}, error) {
|
|
return _StickerMarket.Contract.GetTokenData(&_StickerMarket.CallOpts, _tokenId)
|
|
}
|
|
|
|
// GetTokenData is a free data retrieval call binding the contract method 0xb09afec1.
|
|
//
|
|
// Solidity: function getTokenData(uint256 _tokenId) view returns(bytes4[] category, uint256 timestamp, bytes contenthash)
|
|
func (_StickerMarket *StickerMarketCallerSession) GetTokenData(_tokenId *big.Int) (struct {
|
|
Category [][4]byte
|
|
Timestamp *big.Int
|
|
Contenthash []byte
|
|
}, error) {
|
|
return _StickerMarket.Contract.GetTokenData(&_StickerMarket.CallOpts, _tokenId)
|
|
}
|
|
|
|
// Snt is a free data retrieval call binding the contract method 0x060eb520.
|
|
//
|
|
// Solidity: function snt() view returns(address)
|
|
func (_StickerMarket *StickerMarketCaller) Snt(opts *bind.CallOpts) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _StickerMarket.contract.Call(opts, &out, "snt")
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Snt is a free data retrieval call binding the contract method 0x060eb520.
|
|
//
|
|
// Solidity: function snt() view returns(address)
|
|
func (_StickerMarket *StickerMarketSession) Snt() (common.Address, error) {
|
|
return _StickerMarket.Contract.Snt(&_StickerMarket.CallOpts)
|
|
}
|
|
|
|
// Snt is a free data retrieval call binding the contract method 0x060eb520.
|
|
//
|
|
// Solidity: function snt() view returns(address)
|
|
func (_StickerMarket *StickerMarketCallerSession) Snt() (common.Address, error) {
|
|
return _StickerMarket.Contract.Snt(&_StickerMarket.CallOpts)
|
|
}
|
|
|
|
// State is a free data retrieval call binding the contract method 0xc19d93fb.
|
|
//
|
|
// Solidity: function state() view returns(uint8)
|
|
func (_StickerMarket *StickerMarketCaller) State(opts *bind.CallOpts) (uint8, error) {
|
|
var out []interface{}
|
|
err := _StickerMarket.contract.Call(opts, &out, "state")
|
|
|
|
if err != nil {
|
|
return *new(uint8), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// State is a free data retrieval call binding the contract method 0xc19d93fb.
|
|
//
|
|
// Solidity: function state() view returns(uint8)
|
|
func (_StickerMarket *StickerMarketSession) State() (uint8, error) {
|
|
return _StickerMarket.Contract.State(&_StickerMarket.CallOpts)
|
|
}
|
|
|
|
// State is a free data retrieval call binding the contract method 0xc19d93fb.
|
|
//
|
|
// Solidity: function state() view returns(uint8)
|
|
func (_StickerMarket *StickerMarketCallerSession) State() (uint8, error) {
|
|
return _StickerMarket.Contract.State(&_StickerMarket.CallOpts)
|
|
}
|
|
|
|
// StickerPack is a free data retrieval call binding the contract method 0x4858b015.
|
|
//
|
|
// Solidity: function stickerPack() view returns(address)
|
|
func (_StickerMarket *StickerMarketCaller) StickerPack(opts *bind.CallOpts) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _StickerMarket.contract.Call(opts, &out, "stickerPack")
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// StickerPack is a free data retrieval call binding the contract method 0x4858b015.
|
|
//
|
|
// Solidity: function stickerPack() view returns(address)
|
|
func (_StickerMarket *StickerMarketSession) StickerPack() (common.Address, error) {
|
|
return _StickerMarket.Contract.StickerPack(&_StickerMarket.CallOpts)
|
|
}
|
|
|
|
// StickerPack is a free data retrieval call binding the contract method 0x4858b015.
|
|
//
|
|
// Solidity: function stickerPack() view returns(address)
|
|
func (_StickerMarket *StickerMarketCallerSession) StickerPack() (common.Address, error) {
|
|
return _StickerMarket.Contract.StickerPack(&_StickerMarket.CallOpts)
|
|
}
|
|
|
|
// StickerType is a free data retrieval call binding the contract method 0x0ddd4c87.
|
|
//
|
|
// Solidity: function stickerType() view returns(address)
|
|
func (_StickerMarket *StickerMarketCaller) StickerType(opts *bind.CallOpts) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _StickerMarket.contract.Call(opts, &out, "stickerType")
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// StickerType is a free data retrieval call binding the contract method 0x0ddd4c87.
|
|
//
|
|
// Solidity: function stickerType() view returns(address)
|
|
func (_StickerMarket *StickerMarketSession) StickerType() (common.Address, error) {
|
|
return _StickerMarket.Contract.StickerType(&_StickerMarket.CallOpts)
|
|
}
|
|
|
|
// StickerType is a free data retrieval call binding the contract method 0x0ddd4c87.
|
|
//
|
|
// Solidity: function stickerType() view returns(address)
|
|
func (_StickerMarket *StickerMarketCallerSession) StickerType() (common.Address, error) {
|
|
return _StickerMarket.Contract.StickerType(&_StickerMarket.CallOpts)
|
|
}
|
|
|
|
// BuyToken is a paid mutator transaction binding the contract method 0xf3e62640.
|
|
//
|
|
// Solidity: function buyToken(uint256 _packId, address _destination, uint256 _price) returns(uint256 tokenId)
|
|
func (_StickerMarket *StickerMarketTransactor) BuyToken(opts *bind.TransactOpts, _packId *big.Int, _destination common.Address, _price *big.Int) (*types.Transaction, error) {
|
|
return _StickerMarket.contract.Transact(opts, "buyToken", _packId, _destination, _price)
|
|
}
|
|
|
|
// BuyToken is a paid mutator transaction binding the contract method 0xf3e62640.
|
|
//
|
|
// Solidity: function buyToken(uint256 _packId, address _destination, uint256 _price) returns(uint256 tokenId)
|
|
func (_StickerMarket *StickerMarketSession) BuyToken(_packId *big.Int, _destination common.Address, _price *big.Int) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.BuyToken(&_StickerMarket.TransactOpts, _packId, _destination, _price)
|
|
}
|
|
|
|
// BuyToken is a paid mutator transaction binding the contract method 0xf3e62640.
|
|
//
|
|
// Solidity: function buyToken(uint256 _packId, address _destination, uint256 _price) returns(uint256 tokenId)
|
|
func (_StickerMarket *StickerMarketTransactorSession) BuyToken(_packId *big.Int, _destination common.Address, _price *big.Int) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.BuyToken(&_StickerMarket.TransactOpts, _packId, _destination, _price)
|
|
}
|
|
|
|
// ChangeController is a paid mutator transaction binding the contract method 0x3cebb823.
|
|
//
|
|
// Solidity: function changeController(address _newController) returns()
|
|
func (_StickerMarket *StickerMarketTransactor) ChangeController(opts *bind.TransactOpts, _newController common.Address) (*types.Transaction, error) {
|
|
return _StickerMarket.contract.Transact(opts, "changeController", _newController)
|
|
}
|
|
|
|
// ChangeController is a paid mutator transaction binding the contract method 0x3cebb823.
|
|
//
|
|
// Solidity: function changeController(address _newController) returns()
|
|
func (_StickerMarket *StickerMarketSession) ChangeController(_newController common.Address) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.ChangeController(&_StickerMarket.TransactOpts, _newController)
|
|
}
|
|
|
|
// ChangeController is a paid mutator transaction binding the contract method 0x3cebb823.
|
|
//
|
|
// Solidity: function changeController(address _newController) returns()
|
|
func (_StickerMarket *StickerMarketTransactorSession) ChangeController(_newController common.Address) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.ChangeController(&_StickerMarket.TransactOpts, _newController)
|
|
}
|
|
|
|
// ClaimTokens is a paid mutator transaction binding the contract method 0xdf8de3e7.
|
|
//
|
|
// Solidity: function claimTokens(address _token) returns()
|
|
func (_StickerMarket *StickerMarketTransactor) ClaimTokens(opts *bind.TransactOpts, _token common.Address) (*types.Transaction, error) {
|
|
return _StickerMarket.contract.Transact(opts, "claimTokens", _token)
|
|
}
|
|
|
|
// ClaimTokens is a paid mutator transaction binding the contract method 0xdf8de3e7.
|
|
//
|
|
// Solidity: function claimTokens(address _token) returns()
|
|
func (_StickerMarket *StickerMarketSession) ClaimTokens(_token common.Address) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.ClaimTokens(&_StickerMarket.TransactOpts, _token)
|
|
}
|
|
|
|
// ClaimTokens is a paid mutator transaction binding the contract method 0xdf8de3e7.
|
|
//
|
|
// Solidity: function claimTokens(address _token) returns()
|
|
func (_StickerMarket *StickerMarketTransactorSession) ClaimTokens(_token common.Address) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.ClaimTokens(&_StickerMarket.TransactOpts, _token)
|
|
}
|
|
|
|
// GeneratePack is a paid mutator transaction binding the contract method 0x4c06dc17.
|
|
//
|
|
// Solidity: function generatePack(uint256 _price, uint256 _donate, bytes4[] _category, address _owner, bytes _contenthash) returns(uint256 packId)
|
|
func (_StickerMarket *StickerMarketTransactor) GeneratePack(opts *bind.TransactOpts, _price *big.Int, _donate *big.Int, _category [][4]byte, _owner common.Address, _contenthash []byte) (*types.Transaction, error) {
|
|
return _StickerMarket.contract.Transact(opts, "generatePack", _price, _donate, _category, _owner, _contenthash)
|
|
}
|
|
|
|
// GeneratePack is a paid mutator transaction binding the contract method 0x4c06dc17.
|
|
//
|
|
// Solidity: function generatePack(uint256 _price, uint256 _donate, bytes4[] _category, address _owner, bytes _contenthash) returns(uint256 packId)
|
|
func (_StickerMarket *StickerMarketSession) GeneratePack(_price *big.Int, _donate *big.Int, _category [][4]byte, _owner common.Address, _contenthash []byte) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.GeneratePack(&_StickerMarket.TransactOpts, _price, _donate, _category, _owner, _contenthash)
|
|
}
|
|
|
|
// GeneratePack is a paid mutator transaction binding the contract method 0x4c06dc17.
|
|
//
|
|
// Solidity: function generatePack(uint256 _price, uint256 _donate, bytes4[] _category, address _owner, bytes _contenthash) returns(uint256 packId)
|
|
func (_StickerMarket *StickerMarketTransactorSession) GeneratePack(_price *big.Int, _donate *big.Int, _category [][4]byte, _owner common.Address, _contenthash []byte) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.GeneratePack(&_StickerMarket.TransactOpts, _price, _donate, _category, _owner, _contenthash)
|
|
}
|
|
|
|
// GenerateToken is a paid mutator transaction binding the contract method 0x188b5372.
|
|
//
|
|
// Solidity: function generateToken(address _owner, uint256 _packId) returns(uint256 tokenId)
|
|
func (_StickerMarket *StickerMarketTransactor) GenerateToken(opts *bind.TransactOpts, _owner common.Address, _packId *big.Int) (*types.Transaction, error) {
|
|
return _StickerMarket.contract.Transact(opts, "generateToken", _owner, _packId)
|
|
}
|
|
|
|
// GenerateToken is a paid mutator transaction binding the contract method 0x188b5372.
|
|
//
|
|
// Solidity: function generateToken(address _owner, uint256 _packId) returns(uint256 tokenId)
|
|
func (_StickerMarket *StickerMarketSession) GenerateToken(_owner common.Address, _packId *big.Int) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.GenerateToken(&_StickerMarket.TransactOpts, _owner, _packId)
|
|
}
|
|
|
|
// GenerateToken is a paid mutator transaction binding the contract method 0x188b5372.
|
|
//
|
|
// Solidity: function generateToken(address _owner, uint256 _packId) returns(uint256 tokenId)
|
|
func (_StickerMarket *StickerMarketTransactorSession) GenerateToken(_owner common.Address, _packId *big.Int) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.GenerateToken(&_StickerMarket.TransactOpts, _owner, _packId)
|
|
}
|
|
|
|
// Migrate is a paid mutator transaction binding the contract method 0xce5494bb.
|
|
//
|
|
// Solidity: function migrate(address _newController) returns()
|
|
func (_StickerMarket *StickerMarketTransactor) Migrate(opts *bind.TransactOpts, _newController common.Address) (*types.Transaction, error) {
|
|
return _StickerMarket.contract.Transact(opts, "migrate", _newController)
|
|
}
|
|
|
|
// Migrate is a paid mutator transaction binding the contract method 0xce5494bb.
|
|
//
|
|
// Solidity: function migrate(address _newController) returns()
|
|
func (_StickerMarket *StickerMarketSession) Migrate(_newController common.Address) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.Migrate(&_StickerMarket.TransactOpts, _newController)
|
|
}
|
|
|
|
// Migrate is a paid mutator transaction binding the contract method 0xce5494bb.
|
|
//
|
|
// Solidity: function migrate(address _newController) returns()
|
|
func (_StickerMarket *StickerMarketTransactorSession) Migrate(_newController common.Address) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.Migrate(&_StickerMarket.TransactOpts, _newController)
|
|
}
|
|
|
|
// PurgePack is a paid mutator transaction binding the contract method 0x00b3c91b.
|
|
//
|
|
// Solidity: function purgePack(uint256 _packId, uint256 _limit) returns()
|
|
func (_StickerMarket *StickerMarketTransactor) PurgePack(opts *bind.TransactOpts, _packId *big.Int, _limit *big.Int) (*types.Transaction, error) {
|
|
return _StickerMarket.contract.Transact(opts, "purgePack", _packId, _limit)
|
|
}
|
|
|
|
// PurgePack is a paid mutator transaction binding the contract method 0x00b3c91b.
|
|
//
|
|
// Solidity: function purgePack(uint256 _packId, uint256 _limit) returns()
|
|
func (_StickerMarket *StickerMarketSession) PurgePack(_packId *big.Int, _limit *big.Int) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.PurgePack(&_StickerMarket.TransactOpts, _packId, _limit)
|
|
}
|
|
|
|
// PurgePack is a paid mutator transaction binding the contract method 0x00b3c91b.
|
|
//
|
|
// Solidity: function purgePack(uint256 _packId, uint256 _limit) returns()
|
|
func (_StickerMarket *StickerMarketTransactorSession) PurgePack(_packId *big.Int, _limit *big.Int) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.PurgePack(&_StickerMarket.TransactOpts, _packId, _limit)
|
|
}
|
|
|
|
// ReceiveApproval is a paid mutator transaction binding the contract method 0x8f4ffcb1.
|
|
//
|
|
// Solidity: function receiveApproval(address _from, uint256 _value, address _token, bytes _data) returns()
|
|
func (_StickerMarket *StickerMarketTransactor) ReceiveApproval(opts *bind.TransactOpts, _from common.Address, _value *big.Int, _token common.Address, _data []byte) (*types.Transaction, error) {
|
|
return _StickerMarket.contract.Transact(opts, "receiveApproval", _from, _value, _token, _data)
|
|
}
|
|
|
|
// ReceiveApproval is a paid mutator transaction binding the contract method 0x8f4ffcb1.
|
|
//
|
|
// Solidity: function receiveApproval(address _from, uint256 _value, address _token, bytes _data) returns()
|
|
func (_StickerMarket *StickerMarketSession) ReceiveApproval(_from common.Address, _value *big.Int, _token common.Address, _data []byte) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.ReceiveApproval(&_StickerMarket.TransactOpts, _from, _value, _token, _data)
|
|
}
|
|
|
|
// ReceiveApproval is a paid mutator transaction binding the contract method 0x8f4ffcb1.
|
|
//
|
|
// Solidity: function receiveApproval(address _from, uint256 _value, address _token, bytes _data) returns()
|
|
func (_StickerMarket *StickerMarketTransactorSession) ReceiveApproval(_from common.Address, _value *big.Int, _token common.Address, _data []byte) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.ReceiveApproval(&_StickerMarket.TransactOpts, _from, _value, _token, _data)
|
|
}
|
|
|
|
// RegisterPack is a paid mutator transaction binding the contract method 0x1cf75710.
|
|
//
|
|
// Solidity: function registerPack(uint256 _price, uint256 _donate, bytes4[] _category, address _owner, bytes _contenthash, uint256 _fee) returns(uint256 packId)
|
|
func (_StickerMarket *StickerMarketTransactor) RegisterPack(opts *bind.TransactOpts, _price *big.Int, _donate *big.Int, _category [][4]byte, _owner common.Address, _contenthash []byte, _fee *big.Int) (*types.Transaction, error) {
|
|
return _StickerMarket.contract.Transact(opts, "registerPack", _price, _donate, _category, _owner, _contenthash, _fee)
|
|
}
|
|
|
|
// RegisterPack is a paid mutator transaction binding the contract method 0x1cf75710.
|
|
//
|
|
// Solidity: function registerPack(uint256 _price, uint256 _donate, bytes4[] _category, address _owner, bytes _contenthash, uint256 _fee) returns(uint256 packId)
|
|
func (_StickerMarket *StickerMarketSession) RegisterPack(_price *big.Int, _donate *big.Int, _category [][4]byte, _owner common.Address, _contenthash []byte, _fee *big.Int) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.RegisterPack(&_StickerMarket.TransactOpts, _price, _donate, _category, _owner, _contenthash, _fee)
|
|
}
|
|
|
|
// RegisterPack is a paid mutator transaction binding the contract method 0x1cf75710.
|
|
//
|
|
// Solidity: function registerPack(uint256 _price, uint256 _donate, bytes4[] _category, address _owner, bytes _contenthash, uint256 _fee) returns(uint256 packId)
|
|
func (_StickerMarket *StickerMarketTransactorSession) RegisterPack(_price *big.Int, _donate *big.Int, _category [][4]byte, _owner common.Address, _contenthash []byte, _fee *big.Int) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.RegisterPack(&_StickerMarket.TransactOpts, _price, _donate, _category, _owner, _contenthash, _fee)
|
|
}
|
|
|
|
// SetBurnRate is a paid mutator transaction binding the contract method 0x189d165e.
|
|
//
|
|
// Solidity: function setBurnRate(uint256 _value) returns()
|
|
func (_StickerMarket *StickerMarketTransactor) SetBurnRate(opts *bind.TransactOpts, _value *big.Int) (*types.Transaction, error) {
|
|
return _StickerMarket.contract.Transact(opts, "setBurnRate", _value)
|
|
}
|
|
|
|
// SetBurnRate is a paid mutator transaction binding the contract method 0x189d165e.
|
|
//
|
|
// Solidity: function setBurnRate(uint256 _value) returns()
|
|
func (_StickerMarket *StickerMarketSession) SetBurnRate(_value *big.Int) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.SetBurnRate(&_StickerMarket.TransactOpts, _value)
|
|
}
|
|
|
|
// SetBurnRate is a paid mutator transaction binding the contract method 0x189d165e.
|
|
//
|
|
// Solidity: function setBurnRate(uint256 _value) returns()
|
|
func (_StickerMarket *StickerMarketTransactorSession) SetBurnRate(_value *big.Int) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.SetBurnRate(&_StickerMarket.TransactOpts, _value)
|
|
}
|
|
|
|
// SetMarketState is a paid mutator transaction binding the contract method 0x536b0445.
|
|
//
|
|
// Solidity: function setMarketState(uint8 _state) returns()
|
|
func (_StickerMarket *StickerMarketTransactor) SetMarketState(opts *bind.TransactOpts, _state uint8) (*types.Transaction, error) {
|
|
return _StickerMarket.contract.Transact(opts, "setMarketState", _state)
|
|
}
|
|
|
|
// SetMarketState is a paid mutator transaction binding the contract method 0x536b0445.
|
|
//
|
|
// Solidity: function setMarketState(uint8 _state) returns()
|
|
func (_StickerMarket *StickerMarketSession) SetMarketState(_state uint8) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.SetMarketState(&_StickerMarket.TransactOpts, _state)
|
|
}
|
|
|
|
// SetMarketState is a paid mutator transaction binding the contract method 0x536b0445.
|
|
//
|
|
// Solidity: function setMarketState(uint8 _state) returns()
|
|
func (_StickerMarket *StickerMarketTransactorSession) SetMarketState(_state uint8) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.SetMarketState(&_StickerMarket.TransactOpts, _state)
|
|
}
|
|
|
|
// SetRegisterFee is a paid mutator transaction binding the contract method 0x92be2ab8.
|
|
//
|
|
// Solidity: function setRegisterFee(uint256 _value) returns()
|
|
func (_StickerMarket *StickerMarketTransactor) SetRegisterFee(opts *bind.TransactOpts, _value *big.Int) (*types.Transaction, error) {
|
|
return _StickerMarket.contract.Transact(opts, "setRegisterFee", _value)
|
|
}
|
|
|
|
// SetRegisterFee is a paid mutator transaction binding the contract method 0x92be2ab8.
|
|
//
|
|
// Solidity: function setRegisterFee(uint256 _value) returns()
|
|
func (_StickerMarket *StickerMarketSession) SetRegisterFee(_value *big.Int) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.SetRegisterFee(&_StickerMarket.TransactOpts, _value)
|
|
}
|
|
|
|
// SetRegisterFee is a paid mutator transaction binding the contract method 0x92be2ab8.
|
|
//
|
|
// Solidity: function setRegisterFee(uint256 _value) returns()
|
|
func (_StickerMarket *StickerMarketTransactorSession) SetRegisterFee(_value *big.Int) (*types.Transaction, error) {
|
|
return _StickerMarket.Contract.SetRegisterFee(&_StickerMarket.TransactOpts, _value)
|
|
}
|
|
|
|
// StickerMarketBurnRateIterator is returned from FilterBurnRate and is used to iterate over the raw logs and unpacked data for BurnRate events raised by the StickerMarket contract.
|
|
type StickerMarketBurnRateIterator struct {
|
|
Event *StickerMarketBurnRate // 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 *StickerMarketBurnRateIterator) 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(StickerMarketBurnRate)
|
|
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(StickerMarketBurnRate)
|
|
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 *StickerMarketBurnRateIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerMarketBurnRateIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerMarketBurnRate represents a BurnRate event raised by the StickerMarket contract.
|
|
type StickerMarketBurnRate struct {
|
|
Value *big.Int
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterBurnRate is a free log retrieval operation binding the contract event 0x59701ed6f46ff3f5c94b1b741d5b3f2968eb7a0ae31d2cf2a3a9f2153d18b514.
|
|
//
|
|
// Solidity: event BurnRate(uint256 value)
|
|
func (_StickerMarket *StickerMarketFilterer) FilterBurnRate(opts *bind.FilterOpts) (*StickerMarketBurnRateIterator, error) {
|
|
|
|
logs, sub, err := _StickerMarket.contract.FilterLogs(opts, "BurnRate")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerMarketBurnRateIterator{contract: _StickerMarket.contract, event: "BurnRate", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchBurnRate is a free log subscription operation binding the contract event 0x59701ed6f46ff3f5c94b1b741d5b3f2968eb7a0ae31d2cf2a3a9f2153d18b514.
|
|
//
|
|
// Solidity: event BurnRate(uint256 value)
|
|
func (_StickerMarket *StickerMarketFilterer) WatchBurnRate(opts *bind.WatchOpts, sink chan<- *StickerMarketBurnRate) (event.Subscription, error) {
|
|
|
|
logs, sub, err := _StickerMarket.contract.WatchLogs(opts, "BurnRate")
|
|
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(StickerMarketBurnRate)
|
|
if err := _StickerMarket.contract.UnpackLog(event, "BurnRate", 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
|
|
}
|
|
|
|
// ParseBurnRate is a log parse operation binding the contract event 0x59701ed6f46ff3f5c94b1b741d5b3f2968eb7a0ae31d2cf2a3a9f2153d18b514.
|
|
//
|
|
// Solidity: event BurnRate(uint256 value)
|
|
func (_StickerMarket *StickerMarketFilterer) ParseBurnRate(log types.Log) (*StickerMarketBurnRate, error) {
|
|
event := new(StickerMarketBurnRate)
|
|
if err := _StickerMarket.contract.UnpackLog(event, "BurnRate", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerMarketClaimedTokensIterator is returned from FilterClaimedTokens and is used to iterate over the raw logs and unpacked data for ClaimedTokens events raised by the StickerMarket contract.
|
|
type StickerMarketClaimedTokensIterator struct {
|
|
Event *StickerMarketClaimedTokens // 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 *StickerMarketClaimedTokensIterator) 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(StickerMarketClaimedTokens)
|
|
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(StickerMarketClaimedTokens)
|
|
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 *StickerMarketClaimedTokensIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerMarketClaimedTokensIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerMarketClaimedTokens represents a ClaimedTokens event raised by the StickerMarket contract.
|
|
type StickerMarketClaimedTokens struct {
|
|
Token common.Address
|
|
Controller common.Address
|
|
Amount *big.Int
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterClaimedTokens is a free log retrieval operation binding the contract event 0xf931edb47c50b4b4104c187b5814a9aef5f709e17e2ecf9617e860cacade929c.
|
|
//
|
|
// Solidity: event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount)
|
|
func (_StickerMarket *StickerMarketFilterer) FilterClaimedTokens(opts *bind.FilterOpts, _token []common.Address, _controller []common.Address) (*StickerMarketClaimedTokensIterator, error) {
|
|
|
|
var _tokenRule []interface{}
|
|
for _, _tokenItem := range _token {
|
|
_tokenRule = append(_tokenRule, _tokenItem)
|
|
}
|
|
var _controllerRule []interface{}
|
|
for _, _controllerItem := range _controller {
|
|
_controllerRule = append(_controllerRule, _controllerItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerMarket.contract.FilterLogs(opts, "ClaimedTokens", _tokenRule, _controllerRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerMarketClaimedTokensIterator{contract: _StickerMarket.contract, event: "ClaimedTokens", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchClaimedTokens is a free log subscription operation binding the contract event 0xf931edb47c50b4b4104c187b5814a9aef5f709e17e2ecf9617e860cacade929c.
|
|
//
|
|
// Solidity: event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount)
|
|
func (_StickerMarket *StickerMarketFilterer) WatchClaimedTokens(opts *bind.WatchOpts, sink chan<- *StickerMarketClaimedTokens, _token []common.Address, _controller []common.Address) (event.Subscription, error) {
|
|
|
|
var _tokenRule []interface{}
|
|
for _, _tokenItem := range _token {
|
|
_tokenRule = append(_tokenRule, _tokenItem)
|
|
}
|
|
var _controllerRule []interface{}
|
|
for _, _controllerItem := range _controller {
|
|
_controllerRule = append(_controllerRule, _controllerItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerMarket.contract.WatchLogs(opts, "ClaimedTokens", _tokenRule, _controllerRule)
|
|
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(StickerMarketClaimedTokens)
|
|
if err := _StickerMarket.contract.UnpackLog(event, "ClaimedTokens", 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
|
|
}
|
|
|
|
// ParseClaimedTokens is a log parse operation binding the contract event 0xf931edb47c50b4b4104c187b5814a9aef5f709e17e2ecf9617e860cacade929c.
|
|
//
|
|
// Solidity: event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount)
|
|
func (_StickerMarket *StickerMarketFilterer) ParseClaimedTokens(log types.Log) (*StickerMarketClaimedTokens, error) {
|
|
event := new(StickerMarketClaimedTokens)
|
|
if err := _StickerMarket.contract.UnpackLog(event, "ClaimedTokens", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerMarketMarketStateIterator is returned from FilterMarketState and is used to iterate over the raw logs and unpacked data for MarketState events raised by the StickerMarket contract.
|
|
type StickerMarketMarketStateIterator struct {
|
|
Event *StickerMarketMarketState // 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 *StickerMarketMarketStateIterator) 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(StickerMarketMarketState)
|
|
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(StickerMarketMarketState)
|
|
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 *StickerMarketMarketStateIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerMarketMarketStateIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerMarketMarketState represents a MarketState event raised by the StickerMarket contract.
|
|
type StickerMarketMarketState struct {
|
|
State uint8
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterMarketState is a free log retrieval operation binding the contract event 0x9f17f1d96f7bb1d5a573d638f26fdb9fa651427eb2e7b36481cd5e1351581e58.
|
|
//
|
|
// Solidity: event MarketState(uint8 state)
|
|
func (_StickerMarket *StickerMarketFilterer) FilterMarketState(opts *bind.FilterOpts) (*StickerMarketMarketStateIterator, error) {
|
|
|
|
logs, sub, err := _StickerMarket.contract.FilterLogs(opts, "MarketState")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerMarketMarketStateIterator{contract: _StickerMarket.contract, event: "MarketState", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchMarketState is a free log subscription operation binding the contract event 0x9f17f1d96f7bb1d5a573d638f26fdb9fa651427eb2e7b36481cd5e1351581e58.
|
|
//
|
|
// Solidity: event MarketState(uint8 state)
|
|
func (_StickerMarket *StickerMarketFilterer) WatchMarketState(opts *bind.WatchOpts, sink chan<- *StickerMarketMarketState) (event.Subscription, error) {
|
|
|
|
logs, sub, err := _StickerMarket.contract.WatchLogs(opts, "MarketState")
|
|
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(StickerMarketMarketState)
|
|
if err := _StickerMarket.contract.UnpackLog(event, "MarketState", 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
|
|
}
|
|
|
|
// ParseMarketState is a log parse operation binding the contract event 0x9f17f1d96f7bb1d5a573d638f26fdb9fa651427eb2e7b36481cd5e1351581e58.
|
|
//
|
|
// Solidity: event MarketState(uint8 state)
|
|
func (_StickerMarket *StickerMarketFilterer) ParseMarketState(log types.Log) (*StickerMarketMarketState, error) {
|
|
event := new(StickerMarketMarketState)
|
|
if err := _StickerMarket.contract.UnpackLog(event, "MarketState", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerMarketNewControllerIterator is returned from FilterNewController and is used to iterate over the raw logs and unpacked data for NewController events raised by the StickerMarket contract.
|
|
type StickerMarketNewControllerIterator struct {
|
|
Event *StickerMarketNewController // 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 *StickerMarketNewControllerIterator) 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(StickerMarketNewController)
|
|
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(StickerMarketNewController)
|
|
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 *StickerMarketNewControllerIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerMarketNewControllerIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerMarketNewController represents a NewController event raised by the StickerMarket contract.
|
|
type StickerMarketNewController struct {
|
|
Controller common.Address
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterNewController is a free log retrieval operation binding the contract event 0xe253457d9ad994ca9682fc3bbc38c890dca73a2d5ecee3809e548bac8b00d7c6.
|
|
//
|
|
// Solidity: event NewController(address controller)
|
|
func (_StickerMarket *StickerMarketFilterer) FilterNewController(opts *bind.FilterOpts) (*StickerMarketNewControllerIterator, error) {
|
|
|
|
logs, sub, err := _StickerMarket.contract.FilterLogs(opts, "NewController")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerMarketNewControllerIterator{contract: _StickerMarket.contract, event: "NewController", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchNewController is a free log subscription operation binding the contract event 0xe253457d9ad994ca9682fc3bbc38c890dca73a2d5ecee3809e548bac8b00d7c6.
|
|
//
|
|
// Solidity: event NewController(address controller)
|
|
func (_StickerMarket *StickerMarketFilterer) WatchNewController(opts *bind.WatchOpts, sink chan<- *StickerMarketNewController) (event.Subscription, error) {
|
|
|
|
logs, sub, err := _StickerMarket.contract.WatchLogs(opts, "NewController")
|
|
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(StickerMarketNewController)
|
|
if err := _StickerMarket.contract.UnpackLog(event, "NewController", 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
|
|
}
|
|
|
|
// ParseNewController is a log parse operation binding the contract event 0xe253457d9ad994ca9682fc3bbc38c890dca73a2d5ecee3809e548bac8b00d7c6.
|
|
//
|
|
// Solidity: event NewController(address controller)
|
|
func (_StickerMarket *StickerMarketFilterer) ParseNewController(log types.Log) (*StickerMarketNewController, error) {
|
|
event := new(StickerMarketNewController)
|
|
if err := _StickerMarket.contract.UnpackLog(event, "NewController", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerMarketRegisterIterator is returned from FilterRegister and is used to iterate over the raw logs and unpacked data for Register events raised by the StickerMarket contract.
|
|
type StickerMarketRegisterIterator struct {
|
|
Event *StickerMarketRegister // 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 *StickerMarketRegisterIterator) 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(StickerMarketRegister)
|
|
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(StickerMarketRegister)
|
|
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 *StickerMarketRegisterIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerMarketRegisterIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerMarketRegister represents a Register event raised by the StickerMarket contract.
|
|
type StickerMarketRegister struct {
|
|
PackId *big.Int
|
|
DataPrice *big.Int
|
|
Contenthash []byte
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterRegister is a free log retrieval operation binding the contract event 0x977f348a33aa09ea5592a5999ead89ce5390634d548c226c6a32c8f18b93e082.
|
|
//
|
|
// Solidity: event Register(uint256 indexed packId, uint256 dataPrice, bytes contenthash)
|
|
func (_StickerMarket *StickerMarketFilterer) FilterRegister(opts *bind.FilterOpts, packId []*big.Int) (*StickerMarketRegisterIterator, error) {
|
|
|
|
var packIdRule []interface{}
|
|
for _, packIdItem := range packId {
|
|
packIdRule = append(packIdRule, packIdItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerMarket.contract.FilterLogs(opts, "Register", packIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerMarketRegisterIterator{contract: _StickerMarket.contract, event: "Register", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchRegister is a free log subscription operation binding the contract event 0x977f348a33aa09ea5592a5999ead89ce5390634d548c226c6a32c8f18b93e082.
|
|
//
|
|
// Solidity: event Register(uint256 indexed packId, uint256 dataPrice, bytes contenthash)
|
|
func (_StickerMarket *StickerMarketFilterer) WatchRegister(opts *bind.WatchOpts, sink chan<- *StickerMarketRegister, packId []*big.Int) (event.Subscription, error) {
|
|
|
|
var packIdRule []interface{}
|
|
for _, packIdItem := range packId {
|
|
packIdRule = append(packIdRule, packIdItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerMarket.contract.WatchLogs(opts, "Register", packIdRule)
|
|
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(StickerMarketRegister)
|
|
if err := _StickerMarket.contract.UnpackLog(event, "Register", 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
|
|
}
|
|
|
|
// ParseRegister is a log parse operation binding the contract event 0x977f348a33aa09ea5592a5999ead89ce5390634d548c226c6a32c8f18b93e082.
|
|
//
|
|
// Solidity: event Register(uint256 indexed packId, uint256 dataPrice, bytes contenthash)
|
|
func (_StickerMarket *StickerMarketFilterer) ParseRegister(log types.Log) (*StickerMarketRegister, error) {
|
|
event := new(StickerMarketRegister)
|
|
if err := _StickerMarket.contract.UnpackLog(event, "Register", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerMarketRegisterFeeIterator is returned from FilterRegisterFee and is used to iterate over the raw logs and unpacked data for RegisterFee events raised by the StickerMarket contract.
|
|
type StickerMarketRegisterFeeIterator struct {
|
|
Event *StickerMarketRegisterFee // 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 *StickerMarketRegisterFeeIterator) 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(StickerMarketRegisterFee)
|
|
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(StickerMarketRegisterFee)
|
|
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 *StickerMarketRegisterFeeIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerMarketRegisterFeeIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerMarketRegisterFee represents a RegisterFee event raised by the StickerMarket contract.
|
|
type StickerMarketRegisterFee struct {
|
|
Value *big.Int
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterRegisterFee is a free log retrieval operation binding the contract event 0x1d4a2348bf98e0fa847f28a7db9967b1327ac954c312b659b65a860bb6959172.
|
|
//
|
|
// Solidity: event RegisterFee(uint256 value)
|
|
func (_StickerMarket *StickerMarketFilterer) FilterRegisterFee(opts *bind.FilterOpts) (*StickerMarketRegisterFeeIterator, error) {
|
|
|
|
logs, sub, err := _StickerMarket.contract.FilterLogs(opts, "RegisterFee")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerMarketRegisterFeeIterator{contract: _StickerMarket.contract, event: "RegisterFee", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchRegisterFee is a free log subscription operation binding the contract event 0x1d4a2348bf98e0fa847f28a7db9967b1327ac954c312b659b65a860bb6959172.
|
|
//
|
|
// Solidity: event RegisterFee(uint256 value)
|
|
func (_StickerMarket *StickerMarketFilterer) WatchRegisterFee(opts *bind.WatchOpts, sink chan<- *StickerMarketRegisterFee) (event.Subscription, error) {
|
|
|
|
logs, sub, err := _StickerMarket.contract.WatchLogs(opts, "RegisterFee")
|
|
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(StickerMarketRegisterFee)
|
|
if err := _StickerMarket.contract.UnpackLog(event, "RegisterFee", 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
|
|
}
|
|
|
|
// ParseRegisterFee is a log parse operation binding the contract event 0x1d4a2348bf98e0fa847f28a7db9967b1327ac954c312b659b65a860bb6959172.
|
|
//
|
|
// Solidity: event RegisterFee(uint256 value)
|
|
func (_StickerMarket *StickerMarketFilterer) ParseRegisterFee(log types.Log) (*StickerMarketRegisterFee, error) {
|
|
event := new(StickerMarketRegisterFee)
|
|
if err := _StickerMarket.contract.UnpackLog(event, "RegisterFee", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerMarketTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the StickerMarket contract.
|
|
type StickerMarketTransferIterator struct {
|
|
Event *StickerMarketTransfer // 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 *StickerMarketTransferIterator) 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(StickerMarketTransfer)
|
|
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(StickerMarketTransfer)
|
|
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 *StickerMarketTransferIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerMarketTransferIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerMarketTransfer represents a Transfer event raised by the StickerMarket contract.
|
|
type StickerMarketTransfer 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 indexed value)
|
|
func (_StickerMarket *StickerMarketFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, value []*big.Int) (*StickerMarketTransferIterator, error) {
|
|
|
|
var fromRule []interface{}
|
|
for _, fromItem := range from {
|
|
fromRule = append(fromRule, fromItem)
|
|
}
|
|
var toRule []interface{}
|
|
for _, toItem := range to {
|
|
toRule = append(toRule, toItem)
|
|
}
|
|
var valueRule []interface{}
|
|
for _, valueItem := range value {
|
|
valueRule = append(valueRule, valueItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerMarket.contract.FilterLogs(opts, "Transfer", fromRule, toRule, valueRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerMarketTransferIterator{contract: _StickerMarket.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 indexed value)
|
|
func (_StickerMarket *StickerMarketFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *StickerMarketTransfer, from []common.Address, to []common.Address, value []*big.Int) (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)
|
|
}
|
|
var valueRule []interface{}
|
|
for _, valueItem := range value {
|
|
valueRule = append(valueRule, valueItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerMarket.contract.WatchLogs(opts, "Transfer", fromRule, toRule, valueRule)
|
|
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(StickerMarketTransfer)
|
|
if err := _StickerMarket.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 indexed value)
|
|
func (_StickerMarket *StickerMarketFilterer) ParseTransfer(log types.Log) (*StickerMarketTransfer, error) {
|
|
event := new(StickerMarketTransfer)
|
|
if err := _StickerMarket.contract.UnpackLog(event, "Transfer", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerPackABI is the input ABI used to generate the binding from.
|
|
const StickerPackABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"getApproved\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\"},{\"name\":\"_packId\",\"type\":\"uint256\"}],\"name\":\"generateToken\",\"outputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"tokenOfOwnerByIndex\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_newController\",\"type\":\"address\"}],\"name\":\"changeController\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"tokenByIndex\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"ownerOf\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"tokenCount\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"tokenPackId\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"},{\"name\":\"_data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"tokenURI\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_token\",\"type\":\"address\"}],\"name\":\"claimTokens\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"controller\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"approved\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"_token\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"_controller\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"ClaimedTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"controller\",\"type\":\"address\"}],\"name\":\"NewController\",\"type\":\"event\"}]"
|
|
|
|
// StickerPackFuncSigs maps the 4-byte function signature to its string representation.
|
|
var StickerPackFuncSigs = map[string]string{
|
|
"095ea7b3": "approve(address,uint256)",
|
|
"70a08231": "balanceOf(address)",
|
|
"3cebb823": "changeController(address)",
|
|
"df8de3e7": "claimTokens(address)",
|
|
"f77c4791": "controller()",
|
|
"188b5372": "generateToken(address,uint256)",
|
|
"081812fc": "getApproved(uint256)",
|
|
"e985e9c5": "isApprovedForAll(address,address)",
|
|
"06fdde03": "name()",
|
|
"6352211e": "ownerOf(uint256)",
|
|
"42842e0e": "safeTransferFrom(address,address,uint256)",
|
|
"b88d4fde": "safeTransferFrom(address,address,uint256,bytes)",
|
|
"a22cb465": "setApprovalForAll(address,bool)",
|
|
"01ffc9a7": "supportsInterface(bytes4)",
|
|
"95d89b41": "symbol()",
|
|
"4f6ccce7": "tokenByIndex(uint256)",
|
|
"9f181b5e": "tokenCount()",
|
|
"2f745c59": "tokenOfOwnerByIndex(address,uint256)",
|
|
"a546af4c": "tokenPackId(uint256)",
|
|
"c87b56dd": "tokenURI(uint256)",
|
|
"18160ddd": "totalSupply()",
|
|
"23b872dd": "transferFrom(address,address,uint256)",
|
|
}
|
|
|
|
// StickerPack is an auto generated Go binding around an Ethereum contract.
|
|
type StickerPack struct {
|
|
StickerPackCaller // Read-only binding to the contract
|
|
StickerPackTransactor // Write-only binding to the contract
|
|
StickerPackFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// StickerPackCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type StickerPackCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// StickerPackTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type StickerPackTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// StickerPackFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type StickerPackFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// StickerPackSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type StickerPackSession struct {
|
|
Contract *StickerPack // 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
|
|
}
|
|
|
|
// StickerPackCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type StickerPackCallerSession struct {
|
|
Contract *StickerPackCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// StickerPackTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type StickerPackTransactorSession struct {
|
|
Contract *StickerPackTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// StickerPackRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type StickerPackRaw struct {
|
|
Contract *StickerPack // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// StickerPackCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type StickerPackCallerRaw struct {
|
|
Contract *StickerPackCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// StickerPackTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type StickerPackTransactorRaw struct {
|
|
Contract *StickerPackTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewStickerPack creates a new instance of StickerPack, bound to a specific deployed contract.
|
|
func NewStickerPack(address common.Address, backend bind.ContractBackend) (*StickerPack, error) {
|
|
contract, err := bindStickerPack(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerPack{StickerPackCaller: StickerPackCaller{contract: contract}, StickerPackTransactor: StickerPackTransactor{contract: contract}, StickerPackFilterer: StickerPackFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewStickerPackCaller creates a new read-only instance of StickerPack, bound to a specific deployed contract.
|
|
func NewStickerPackCaller(address common.Address, caller bind.ContractCaller) (*StickerPackCaller, error) {
|
|
contract, err := bindStickerPack(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerPackCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewStickerPackTransactor creates a new write-only instance of StickerPack, bound to a specific deployed contract.
|
|
func NewStickerPackTransactor(address common.Address, transactor bind.ContractTransactor) (*StickerPackTransactor, error) {
|
|
contract, err := bindStickerPack(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerPackTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewStickerPackFilterer creates a new log filterer instance of StickerPack, bound to a specific deployed contract.
|
|
func NewStickerPackFilterer(address common.Address, filterer bind.ContractFilterer) (*StickerPackFilterer, error) {
|
|
contract, err := bindStickerPack(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerPackFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindStickerPack binds a generic wrapper to an already deployed contract.
|
|
func bindStickerPack(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(StickerPackABI))
|
|
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 (_StickerPack *StickerPackRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _StickerPack.Contract.StickerPackCaller.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 (_StickerPack *StickerPackRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _StickerPack.Contract.StickerPackTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_StickerPack *StickerPackRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _StickerPack.Contract.StickerPackTransactor.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 (_StickerPack *StickerPackCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _StickerPack.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 (_StickerPack *StickerPackTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _StickerPack.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_StickerPack *StickerPackTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _StickerPack.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address owner) view returns(uint256)
|
|
func (_StickerPack *StickerPackCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _StickerPack.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 (_StickerPack *StickerPackSession) BalanceOf(owner common.Address) (*big.Int, error) {
|
|
return _StickerPack.Contract.BalanceOf(&_StickerPack.CallOpts, owner)
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address owner) view returns(uint256)
|
|
func (_StickerPack *StickerPackCallerSession) BalanceOf(owner common.Address) (*big.Int, error) {
|
|
return _StickerPack.Contract.BalanceOf(&_StickerPack.CallOpts, owner)
|
|
}
|
|
|
|
// Controller is a free data retrieval call binding the contract method 0xf77c4791.
|
|
//
|
|
// Solidity: function controller() view returns(address)
|
|
func (_StickerPack *StickerPackCaller) Controller(opts *bind.CallOpts) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _StickerPack.contract.Call(opts, &out, "controller")
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Controller is a free data retrieval call binding the contract method 0xf77c4791.
|
|
//
|
|
// Solidity: function controller() view returns(address)
|
|
func (_StickerPack *StickerPackSession) Controller() (common.Address, error) {
|
|
return _StickerPack.Contract.Controller(&_StickerPack.CallOpts)
|
|
}
|
|
|
|
// Controller is a free data retrieval call binding the contract method 0xf77c4791.
|
|
//
|
|
// Solidity: function controller() view returns(address)
|
|
func (_StickerPack *StickerPackCallerSession) Controller() (common.Address, error) {
|
|
return _StickerPack.Contract.Controller(&_StickerPack.CallOpts)
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address)
|
|
func (_StickerPack *StickerPackCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _StickerPack.contract.Call(opts, &out, "getApproved", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address)
|
|
func (_StickerPack *StickerPackSession) GetApproved(tokenId *big.Int) (common.Address, error) {
|
|
return _StickerPack.Contract.GetApproved(&_StickerPack.CallOpts, tokenId)
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address)
|
|
func (_StickerPack *StickerPackCallerSession) GetApproved(tokenId *big.Int) (common.Address, error) {
|
|
return _StickerPack.Contract.GetApproved(&_StickerPack.CallOpts, tokenId)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_StickerPack *StickerPackCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error) {
|
|
var out []interface{}
|
|
err := _StickerPack.contract.Call(opts, &out, "isApprovedForAll", owner, operator)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_StickerPack *StickerPackSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _StickerPack.Contract.IsApprovedForAll(&_StickerPack.CallOpts, owner, operator)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_StickerPack *StickerPackCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _StickerPack.Contract.IsApprovedForAll(&_StickerPack.CallOpts, owner, operator)
|
|
}
|
|
|
|
// Name is a free data retrieval call binding the contract method 0x06fdde03.
|
|
//
|
|
// Solidity: function name() view returns(string)
|
|
func (_StickerPack *StickerPackCaller) Name(opts *bind.CallOpts) (string, error) {
|
|
var out []interface{}
|
|
err := _StickerPack.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 (_StickerPack *StickerPackSession) Name() (string, error) {
|
|
return _StickerPack.Contract.Name(&_StickerPack.CallOpts)
|
|
}
|
|
|
|
// Name is a free data retrieval call binding the contract method 0x06fdde03.
|
|
//
|
|
// Solidity: function name() view returns(string)
|
|
func (_StickerPack *StickerPackCallerSession) Name() (string, error) {
|
|
return _StickerPack.Contract.Name(&_StickerPack.CallOpts)
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address)
|
|
func (_StickerPack *StickerPackCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _StickerPack.contract.Call(opts, &out, "ownerOf", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address)
|
|
func (_StickerPack *StickerPackSession) OwnerOf(tokenId *big.Int) (common.Address, error) {
|
|
return _StickerPack.Contract.OwnerOf(&_StickerPack.CallOpts, tokenId)
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address)
|
|
func (_StickerPack *StickerPackCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error) {
|
|
return _StickerPack.Contract.OwnerOf(&_StickerPack.CallOpts, tokenId)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_StickerPack *StickerPackCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _StickerPack.contract.Call(opts, &out, "supportsInterface", interfaceId)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_StickerPack *StickerPackSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _StickerPack.Contract.SupportsInterface(&_StickerPack.CallOpts, interfaceId)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_StickerPack *StickerPackCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _StickerPack.Contract.SupportsInterface(&_StickerPack.CallOpts, interfaceId)
|
|
}
|
|
|
|
// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
|
|
//
|
|
// Solidity: function symbol() view returns(string)
|
|
func (_StickerPack *StickerPackCaller) Symbol(opts *bind.CallOpts) (string, error) {
|
|
var out []interface{}
|
|
err := _StickerPack.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 (_StickerPack *StickerPackSession) Symbol() (string, error) {
|
|
return _StickerPack.Contract.Symbol(&_StickerPack.CallOpts)
|
|
}
|
|
|
|
// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
|
|
//
|
|
// Solidity: function symbol() view returns(string)
|
|
func (_StickerPack *StickerPackCallerSession) Symbol() (string, error) {
|
|
return _StickerPack.Contract.Symbol(&_StickerPack.CallOpts)
|
|
}
|
|
|
|
// TokenByIndex is a free data retrieval call binding the contract method 0x4f6ccce7.
|
|
//
|
|
// Solidity: function tokenByIndex(uint256 index) view returns(uint256)
|
|
func (_StickerPack *StickerPackCaller) TokenByIndex(opts *bind.CallOpts, index *big.Int) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _StickerPack.contract.Call(opts, &out, "tokenByIndex", index)
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// TokenByIndex is a free data retrieval call binding the contract method 0x4f6ccce7.
|
|
//
|
|
// Solidity: function tokenByIndex(uint256 index) view returns(uint256)
|
|
func (_StickerPack *StickerPackSession) TokenByIndex(index *big.Int) (*big.Int, error) {
|
|
return _StickerPack.Contract.TokenByIndex(&_StickerPack.CallOpts, index)
|
|
}
|
|
|
|
// TokenByIndex is a free data retrieval call binding the contract method 0x4f6ccce7.
|
|
//
|
|
// Solidity: function tokenByIndex(uint256 index) view returns(uint256)
|
|
func (_StickerPack *StickerPackCallerSession) TokenByIndex(index *big.Int) (*big.Int, error) {
|
|
return _StickerPack.Contract.TokenByIndex(&_StickerPack.CallOpts, index)
|
|
}
|
|
|
|
// TokenCount is a free data retrieval call binding the contract method 0x9f181b5e.
|
|
//
|
|
// Solidity: function tokenCount() view returns(uint256)
|
|
func (_StickerPack *StickerPackCaller) TokenCount(opts *bind.CallOpts) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _StickerPack.contract.Call(opts, &out, "tokenCount")
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// TokenCount is a free data retrieval call binding the contract method 0x9f181b5e.
|
|
//
|
|
// Solidity: function tokenCount() view returns(uint256)
|
|
func (_StickerPack *StickerPackSession) TokenCount() (*big.Int, error) {
|
|
return _StickerPack.Contract.TokenCount(&_StickerPack.CallOpts)
|
|
}
|
|
|
|
// TokenCount is a free data retrieval call binding the contract method 0x9f181b5e.
|
|
//
|
|
// Solidity: function tokenCount() view returns(uint256)
|
|
func (_StickerPack *StickerPackCallerSession) TokenCount() (*big.Int, error) {
|
|
return _StickerPack.Contract.TokenCount(&_StickerPack.CallOpts)
|
|
}
|
|
|
|
// TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59.
|
|
//
|
|
// Solidity: function tokenOfOwnerByIndex(address owner, uint256 index) view returns(uint256)
|
|
func (_StickerPack *StickerPackCaller) TokenOfOwnerByIndex(opts *bind.CallOpts, owner common.Address, index *big.Int) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _StickerPack.contract.Call(opts, &out, "tokenOfOwnerByIndex", owner, index)
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59.
|
|
//
|
|
// Solidity: function tokenOfOwnerByIndex(address owner, uint256 index) view returns(uint256)
|
|
func (_StickerPack *StickerPackSession) TokenOfOwnerByIndex(owner common.Address, index *big.Int) (*big.Int, error) {
|
|
return _StickerPack.Contract.TokenOfOwnerByIndex(&_StickerPack.CallOpts, owner, index)
|
|
}
|
|
|
|
// TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59.
|
|
//
|
|
// Solidity: function tokenOfOwnerByIndex(address owner, uint256 index) view returns(uint256)
|
|
func (_StickerPack *StickerPackCallerSession) TokenOfOwnerByIndex(owner common.Address, index *big.Int) (*big.Int, error) {
|
|
return _StickerPack.Contract.TokenOfOwnerByIndex(&_StickerPack.CallOpts, owner, index)
|
|
}
|
|
|
|
// TokenPackId is a free data retrieval call binding the contract method 0xa546af4c.
|
|
//
|
|
// Solidity: function tokenPackId(uint256 ) view returns(uint256)
|
|
func (_StickerPack *StickerPackCaller) TokenPackId(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _StickerPack.contract.Call(opts, &out, "tokenPackId", arg0)
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// TokenPackId is a free data retrieval call binding the contract method 0xa546af4c.
|
|
//
|
|
// Solidity: function tokenPackId(uint256 ) view returns(uint256)
|
|
func (_StickerPack *StickerPackSession) TokenPackId(arg0 *big.Int) (*big.Int, error) {
|
|
return _StickerPack.Contract.TokenPackId(&_StickerPack.CallOpts, arg0)
|
|
}
|
|
|
|
// TokenPackId is a free data retrieval call binding the contract method 0xa546af4c.
|
|
//
|
|
// Solidity: function tokenPackId(uint256 ) view returns(uint256)
|
|
func (_StickerPack *StickerPackCallerSession) TokenPackId(arg0 *big.Int) (*big.Int, error) {
|
|
return _StickerPack.Contract.TokenPackId(&_StickerPack.CallOpts, arg0)
|
|
}
|
|
|
|
// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd.
|
|
//
|
|
// Solidity: function tokenURI(uint256 tokenId) view returns(string)
|
|
func (_StickerPack *StickerPackCaller) TokenURI(opts *bind.CallOpts, tokenId *big.Int) (string, error) {
|
|
var out []interface{}
|
|
err := _StickerPack.contract.Call(opts, &out, "tokenURI", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(string), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(string)).(*string)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd.
|
|
//
|
|
// Solidity: function tokenURI(uint256 tokenId) view returns(string)
|
|
func (_StickerPack *StickerPackSession) TokenURI(tokenId *big.Int) (string, error) {
|
|
return _StickerPack.Contract.TokenURI(&_StickerPack.CallOpts, tokenId)
|
|
}
|
|
|
|
// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd.
|
|
//
|
|
// Solidity: function tokenURI(uint256 tokenId) view returns(string)
|
|
func (_StickerPack *StickerPackCallerSession) TokenURI(tokenId *big.Int) (string, error) {
|
|
return _StickerPack.Contract.TokenURI(&_StickerPack.CallOpts, tokenId)
|
|
}
|
|
|
|
// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
|
|
//
|
|
// Solidity: function totalSupply() view returns(uint256)
|
|
func (_StickerPack *StickerPackCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _StickerPack.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 (_StickerPack *StickerPackSession) TotalSupply() (*big.Int, error) {
|
|
return _StickerPack.Contract.TotalSupply(&_StickerPack.CallOpts)
|
|
}
|
|
|
|
// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
|
|
//
|
|
// Solidity: function totalSupply() view returns(uint256)
|
|
func (_StickerPack *StickerPackCallerSession) TotalSupply() (*big.Int, error) {
|
|
return _StickerPack.Contract.TotalSupply(&_StickerPack.CallOpts)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_StickerPack *StickerPackTransactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _StickerPack.contract.Transact(opts, "approve", to, tokenId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_StickerPack *StickerPackSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _StickerPack.Contract.Approve(&_StickerPack.TransactOpts, to, tokenId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_StickerPack *StickerPackTransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _StickerPack.Contract.Approve(&_StickerPack.TransactOpts, to, tokenId)
|
|
}
|
|
|
|
// ChangeController is a paid mutator transaction binding the contract method 0x3cebb823.
|
|
//
|
|
// Solidity: function changeController(address _newController) returns()
|
|
func (_StickerPack *StickerPackTransactor) ChangeController(opts *bind.TransactOpts, _newController common.Address) (*types.Transaction, error) {
|
|
return _StickerPack.contract.Transact(opts, "changeController", _newController)
|
|
}
|
|
|
|
// ChangeController is a paid mutator transaction binding the contract method 0x3cebb823.
|
|
//
|
|
// Solidity: function changeController(address _newController) returns()
|
|
func (_StickerPack *StickerPackSession) ChangeController(_newController common.Address) (*types.Transaction, error) {
|
|
return _StickerPack.Contract.ChangeController(&_StickerPack.TransactOpts, _newController)
|
|
}
|
|
|
|
// ChangeController is a paid mutator transaction binding the contract method 0x3cebb823.
|
|
//
|
|
// Solidity: function changeController(address _newController) returns()
|
|
func (_StickerPack *StickerPackTransactorSession) ChangeController(_newController common.Address) (*types.Transaction, error) {
|
|
return _StickerPack.Contract.ChangeController(&_StickerPack.TransactOpts, _newController)
|
|
}
|
|
|
|
// ClaimTokens is a paid mutator transaction binding the contract method 0xdf8de3e7.
|
|
//
|
|
// Solidity: function claimTokens(address _token) returns()
|
|
func (_StickerPack *StickerPackTransactor) ClaimTokens(opts *bind.TransactOpts, _token common.Address) (*types.Transaction, error) {
|
|
return _StickerPack.contract.Transact(opts, "claimTokens", _token)
|
|
}
|
|
|
|
// ClaimTokens is a paid mutator transaction binding the contract method 0xdf8de3e7.
|
|
//
|
|
// Solidity: function claimTokens(address _token) returns()
|
|
func (_StickerPack *StickerPackSession) ClaimTokens(_token common.Address) (*types.Transaction, error) {
|
|
return _StickerPack.Contract.ClaimTokens(&_StickerPack.TransactOpts, _token)
|
|
}
|
|
|
|
// ClaimTokens is a paid mutator transaction binding the contract method 0xdf8de3e7.
|
|
//
|
|
// Solidity: function claimTokens(address _token) returns()
|
|
func (_StickerPack *StickerPackTransactorSession) ClaimTokens(_token common.Address) (*types.Transaction, error) {
|
|
return _StickerPack.Contract.ClaimTokens(&_StickerPack.TransactOpts, _token)
|
|
}
|
|
|
|
// GenerateToken is a paid mutator transaction binding the contract method 0x188b5372.
|
|
//
|
|
// Solidity: function generateToken(address _owner, uint256 _packId) returns(uint256 tokenId)
|
|
func (_StickerPack *StickerPackTransactor) GenerateToken(opts *bind.TransactOpts, _owner common.Address, _packId *big.Int) (*types.Transaction, error) {
|
|
return _StickerPack.contract.Transact(opts, "generateToken", _owner, _packId)
|
|
}
|
|
|
|
// GenerateToken is a paid mutator transaction binding the contract method 0x188b5372.
|
|
//
|
|
// Solidity: function generateToken(address _owner, uint256 _packId) returns(uint256 tokenId)
|
|
func (_StickerPack *StickerPackSession) GenerateToken(_owner common.Address, _packId *big.Int) (*types.Transaction, error) {
|
|
return _StickerPack.Contract.GenerateToken(&_StickerPack.TransactOpts, _owner, _packId)
|
|
}
|
|
|
|
// GenerateToken is a paid mutator transaction binding the contract method 0x188b5372.
|
|
//
|
|
// Solidity: function generateToken(address _owner, uint256 _packId) returns(uint256 tokenId)
|
|
func (_StickerPack *StickerPackTransactorSession) GenerateToken(_owner common.Address, _packId *big.Int) (*types.Transaction, error) {
|
|
return _StickerPack.Contract.GenerateToken(&_StickerPack.TransactOpts, _owner, _packId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_StickerPack *StickerPackTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _StickerPack.contract.Transact(opts, "safeTransferFrom", from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_StickerPack *StickerPackSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _StickerPack.Contract.SafeTransferFrom(&_StickerPack.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_StickerPack *StickerPackTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _StickerPack.Contract.SafeTransferFrom(&_StickerPack.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes _data) returns()
|
|
func (_StickerPack *StickerPackTransactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error) {
|
|
return _StickerPack.contract.Transact(opts, "safeTransferFrom0", from, to, tokenId, _data)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes _data) returns()
|
|
func (_StickerPack *StickerPackSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error) {
|
|
return _StickerPack.Contract.SafeTransferFrom0(&_StickerPack.TransactOpts, from, to, tokenId, _data)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes _data) returns()
|
|
func (_StickerPack *StickerPackTransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error) {
|
|
return _StickerPack.Contract.SafeTransferFrom0(&_StickerPack.TransactOpts, from, to, tokenId, _data)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address to, bool approved) returns()
|
|
func (_StickerPack *StickerPackTransactor) SetApprovalForAll(opts *bind.TransactOpts, to common.Address, approved bool) (*types.Transaction, error) {
|
|
return _StickerPack.contract.Transact(opts, "setApprovalForAll", to, approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address to, bool approved) returns()
|
|
func (_StickerPack *StickerPackSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error) {
|
|
return _StickerPack.Contract.SetApprovalForAll(&_StickerPack.TransactOpts, to, approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address to, bool approved) returns()
|
|
func (_StickerPack *StickerPackTransactorSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error) {
|
|
return _StickerPack.Contract.SetApprovalForAll(&_StickerPack.TransactOpts, to, approved)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_StickerPack *StickerPackTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _StickerPack.contract.Transact(opts, "transferFrom", from, to, tokenId)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_StickerPack *StickerPackSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _StickerPack.Contract.TransferFrom(&_StickerPack.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_StickerPack *StickerPackTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _StickerPack.Contract.TransferFrom(&_StickerPack.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// StickerPackApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the StickerPack contract.
|
|
type StickerPackApprovalIterator struct {
|
|
Event *StickerPackApproval // 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 *StickerPackApprovalIterator) 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(StickerPackApproval)
|
|
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(StickerPackApproval)
|
|
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 *StickerPackApprovalIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerPackApprovalIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerPackApproval represents a Approval event raised by the StickerPack contract.
|
|
type StickerPackApproval struct {
|
|
Owner common.Address
|
|
Approved common.Address
|
|
TokenId *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 approved, uint256 indexed tokenId)
|
|
func (_StickerPack *StickerPackFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, tokenId []*big.Int) (*StickerPackApprovalIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var approvedRule []interface{}
|
|
for _, approvedItem := range approved {
|
|
approvedRule = append(approvedRule, approvedItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerPack.contract.FilterLogs(opts, "Approval", ownerRule, approvedRule, tokenIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerPackApprovalIterator{contract: _StickerPack.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 approved, uint256 indexed tokenId)
|
|
func (_StickerPack *StickerPackFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *StickerPackApproval, owner []common.Address, approved []common.Address, tokenId []*big.Int) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var approvedRule []interface{}
|
|
for _, approvedItem := range approved {
|
|
approvedRule = append(approvedRule, approvedItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerPack.contract.WatchLogs(opts, "Approval", ownerRule, approvedRule, tokenIdRule)
|
|
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(StickerPackApproval)
|
|
if err := _StickerPack.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 approved, uint256 indexed tokenId)
|
|
func (_StickerPack *StickerPackFilterer) ParseApproval(log types.Log) (*StickerPackApproval, error) {
|
|
event := new(StickerPackApproval)
|
|
if err := _StickerPack.contract.UnpackLog(event, "Approval", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerPackApprovalForAllIterator is returned from FilterApprovalForAll and is used to iterate over the raw logs and unpacked data for ApprovalForAll events raised by the StickerPack contract.
|
|
type StickerPackApprovalForAllIterator struct {
|
|
Event *StickerPackApprovalForAll // 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 *StickerPackApprovalForAllIterator) 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(StickerPackApprovalForAll)
|
|
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(StickerPackApprovalForAll)
|
|
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 *StickerPackApprovalForAllIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerPackApprovalForAllIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerPackApprovalForAll represents a ApprovalForAll event raised by the StickerPack contract.
|
|
type StickerPackApprovalForAll struct {
|
|
Owner common.Address
|
|
Operator common.Address
|
|
Approved bool
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterApprovalForAll is a free log retrieval operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_StickerPack *StickerPackFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*StickerPackApprovalForAllIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerPack.contract.FilterLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerPackApprovalForAllIterator{contract: _StickerPack.contract, event: "ApprovalForAll", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchApprovalForAll is a free log subscription operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_StickerPack *StickerPackFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *StickerPackApprovalForAll, owner []common.Address, operator []common.Address) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerPack.contract.WatchLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
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(StickerPackApprovalForAll)
|
|
if err := _StickerPack.contract.UnpackLog(event, "ApprovalForAll", 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
|
|
}
|
|
|
|
// ParseApprovalForAll is a log parse operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_StickerPack *StickerPackFilterer) ParseApprovalForAll(log types.Log) (*StickerPackApprovalForAll, error) {
|
|
event := new(StickerPackApprovalForAll)
|
|
if err := _StickerPack.contract.UnpackLog(event, "ApprovalForAll", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerPackClaimedTokensIterator is returned from FilterClaimedTokens and is used to iterate over the raw logs and unpacked data for ClaimedTokens events raised by the StickerPack contract.
|
|
type StickerPackClaimedTokensIterator struct {
|
|
Event *StickerPackClaimedTokens // 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 *StickerPackClaimedTokensIterator) 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(StickerPackClaimedTokens)
|
|
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(StickerPackClaimedTokens)
|
|
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 *StickerPackClaimedTokensIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerPackClaimedTokensIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerPackClaimedTokens represents a ClaimedTokens event raised by the StickerPack contract.
|
|
type StickerPackClaimedTokens struct {
|
|
Token common.Address
|
|
Controller common.Address
|
|
Amount *big.Int
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterClaimedTokens is a free log retrieval operation binding the contract event 0xf931edb47c50b4b4104c187b5814a9aef5f709e17e2ecf9617e860cacade929c.
|
|
//
|
|
// Solidity: event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount)
|
|
func (_StickerPack *StickerPackFilterer) FilterClaimedTokens(opts *bind.FilterOpts, _token []common.Address, _controller []common.Address) (*StickerPackClaimedTokensIterator, error) {
|
|
|
|
var _tokenRule []interface{}
|
|
for _, _tokenItem := range _token {
|
|
_tokenRule = append(_tokenRule, _tokenItem)
|
|
}
|
|
var _controllerRule []interface{}
|
|
for _, _controllerItem := range _controller {
|
|
_controllerRule = append(_controllerRule, _controllerItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerPack.contract.FilterLogs(opts, "ClaimedTokens", _tokenRule, _controllerRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerPackClaimedTokensIterator{contract: _StickerPack.contract, event: "ClaimedTokens", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchClaimedTokens is a free log subscription operation binding the contract event 0xf931edb47c50b4b4104c187b5814a9aef5f709e17e2ecf9617e860cacade929c.
|
|
//
|
|
// Solidity: event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount)
|
|
func (_StickerPack *StickerPackFilterer) WatchClaimedTokens(opts *bind.WatchOpts, sink chan<- *StickerPackClaimedTokens, _token []common.Address, _controller []common.Address) (event.Subscription, error) {
|
|
|
|
var _tokenRule []interface{}
|
|
for _, _tokenItem := range _token {
|
|
_tokenRule = append(_tokenRule, _tokenItem)
|
|
}
|
|
var _controllerRule []interface{}
|
|
for _, _controllerItem := range _controller {
|
|
_controllerRule = append(_controllerRule, _controllerItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerPack.contract.WatchLogs(opts, "ClaimedTokens", _tokenRule, _controllerRule)
|
|
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(StickerPackClaimedTokens)
|
|
if err := _StickerPack.contract.UnpackLog(event, "ClaimedTokens", 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
|
|
}
|
|
|
|
// ParseClaimedTokens is a log parse operation binding the contract event 0xf931edb47c50b4b4104c187b5814a9aef5f709e17e2ecf9617e860cacade929c.
|
|
//
|
|
// Solidity: event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount)
|
|
func (_StickerPack *StickerPackFilterer) ParseClaimedTokens(log types.Log) (*StickerPackClaimedTokens, error) {
|
|
event := new(StickerPackClaimedTokens)
|
|
if err := _StickerPack.contract.UnpackLog(event, "ClaimedTokens", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerPackNewControllerIterator is returned from FilterNewController and is used to iterate over the raw logs and unpacked data for NewController events raised by the StickerPack contract.
|
|
type StickerPackNewControllerIterator struct {
|
|
Event *StickerPackNewController // 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 *StickerPackNewControllerIterator) 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(StickerPackNewController)
|
|
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(StickerPackNewController)
|
|
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 *StickerPackNewControllerIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerPackNewControllerIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerPackNewController represents a NewController event raised by the StickerPack contract.
|
|
type StickerPackNewController struct {
|
|
Controller common.Address
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterNewController is a free log retrieval operation binding the contract event 0xe253457d9ad994ca9682fc3bbc38c890dca73a2d5ecee3809e548bac8b00d7c6.
|
|
//
|
|
// Solidity: event NewController(address controller)
|
|
func (_StickerPack *StickerPackFilterer) FilterNewController(opts *bind.FilterOpts) (*StickerPackNewControllerIterator, error) {
|
|
|
|
logs, sub, err := _StickerPack.contract.FilterLogs(opts, "NewController")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerPackNewControllerIterator{contract: _StickerPack.contract, event: "NewController", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchNewController is a free log subscription operation binding the contract event 0xe253457d9ad994ca9682fc3bbc38c890dca73a2d5ecee3809e548bac8b00d7c6.
|
|
//
|
|
// Solidity: event NewController(address controller)
|
|
func (_StickerPack *StickerPackFilterer) WatchNewController(opts *bind.WatchOpts, sink chan<- *StickerPackNewController) (event.Subscription, error) {
|
|
|
|
logs, sub, err := _StickerPack.contract.WatchLogs(opts, "NewController")
|
|
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(StickerPackNewController)
|
|
if err := _StickerPack.contract.UnpackLog(event, "NewController", 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
|
|
}
|
|
|
|
// ParseNewController is a log parse operation binding the contract event 0xe253457d9ad994ca9682fc3bbc38c890dca73a2d5ecee3809e548bac8b00d7c6.
|
|
//
|
|
// Solidity: event NewController(address controller)
|
|
func (_StickerPack *StickerPackFilterer) ParseNewController(log types.Log) (*StickerPackNewController, error) {
|
|
event := new(StickerPackNewController)
|
|
if err := _StickerPack.contract.UnpackLog(event, "NewController", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerPackTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the StickerPack contract.
|
|
type StickerPackTransferIterator struct {
|
|
Event *StickerPackTransfer // 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 *StickerPackTransferIterator) 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(StickerPackTransfer)
|
|
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(StickerPackTransfer)
|
|
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 *StickerPackTransferIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerPackTransferIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerPackTransfer represents a Transfer event raised by the StickerPack contract.
|
|
type StickerPackTransfer struct {
|
|
From common.Address
|
|
To common.Address
|
|
TokenId *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 indexed tokenId)
|
|
func (_StickerPack *StickerPackFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, tokenId []*big.Int) (*StickerPackTransferIterator, error) {
|
|
|
|
var fromRule []interface{}
|
|
for _, fromItem := range from {
|
|
fromRule = append(fromRule, fromItem)
|
|
}
|
|
var toRule []interface{}
|
|
for _, toItem := range to {
|
|
toRule = append(toRule, toItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerPack.contract.FilterLogs(opts, "Transfer", fromRule, toRule, tokenIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerPackTransferIterator{contract: _StickerPack.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 indexed tokenId)
|
|
func (_StickerPack *StickerPackFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *StickerPackTransfer, from []common.Address, to []common.Address, tokenId []*big.Int) (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)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerPack.contract.WatchLogs(opts, "Transfer", fromRule, toRule, tokenIdRule)
|
|
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(StickerPackTransfer)
|
|
if err := _StickerPack.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 indexed tokenId)
|
|
func (_StickerPack *StickerPackFilterer) ParseTransfer(log types.Log) (*StickerPackTransfer, error) {
|
|
event := new(StickerPackTransfer)
|
|
if err := _StickerPack.contract.UnpackLog(event, "Transfer", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerTypeABI is the input ABI used to generate the binding from.
|
|
const StickerTypeABI = "[{\"constant\":false,\"inputs\":[{\"name\":\"_packId\",\"type\":\"uint256\"},{\"name\":\"_limit\",\"type\":\"uint256\"}],\"name\":\"purgePack\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"getApproved\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"tokenOfOwnerByIndex\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_newController\",\"type\":\"address\"}],\"name\":\"changeController\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_price\",\"type\":\"uint256\"},{\"name\":\"_donate\",\"type\":\"uint256\"},{\"name\":\"_category\",\"type\":\"bytes4[]\"},{\"name\":\"_owner\",\"type\":\"address\"},{\"name\":\"_contenthash\",\"type\":\"bytes\"}],\"name\":\"generatePack\",\"outputs\":[{\"name\":\"packId\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"tokenByIndex\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"packCount\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"ownerOf\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_packId\",\"type\":\"uint256\"},{\"name\":\"_contenthash\",\"type\":\"bytes\"}],\"name\":\"setPackContenthash\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_packId\",\"type\":\"uint256\"}],\"name\":\"getPackSummary\",\"outputs\":[{\"name\":\"category\",\"type\":\"bytes4[]\"},{\"name\":\"timestamp\",\"type\":\"uint256\"},{\"name\":\"contenthash\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_packId\",\"type\":\"uint256\"},{\"name\":\"_price\",\"type\":\"uint256\"},{\"name\":\"_donate\",\"type\":\"uint256\"}],\"name\":\"setPackPrice\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_packId\",\"type\":\"uint256\"}],\"name\":\"getPaymentData\",\"outputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"mintable\",\"type\":\"bool\"},{\"name\":\"price\",\"type\":\"uint256\"},{\"name\":\"donate\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_category\",\"type\":\"bytes4\"}],\"name\":\"getCategoryLength\",\"outputs\":[{\"name\":\"size\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_packId\",\"type\":\"uint256\"},{\"name\":\"_category\",\"type\":\"bytes4\"}],\"name\":\"addPackCategory\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_category\",\"type\":\"bytes4\"}],\"name\":\"getAvailablePacks\",\"outputs\":[{\"name\":\"availableIds\",\"type\":\"uint256[]\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_category\",\"type\":\"bytes4\"},{\"name\":\"_index\",\"type\":\"uint256\"}],\"name\":\"getCategoryPack\",\"outputs\":[{\"name\":\"packId\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_packId\",\"type\":\"uint256\"},{\"name\":\"_mintable\",\"type\":\"bool\"}],\"name\":\"setPackState\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"packs\",\"outputs\":[{\"name\":\"mintable\",\"type\":\"bool\"},{\"name\":\"timestamp\",\"type\":\"uint256\"},{\"name\":\"price\",\"type\":\"uint256\"},{\"name\":\"donate\",\"type\":\"uint256\"},{\"name\":\"contenthash\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"tokenId\",\"type\":\"uint256\"},{\"name\":\"_data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"tokenURI\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_packId\",\"type\":\"uint256\"}],\"name\":\"getPackData\",\"outputs\":[{\"name\":\"category\",\"type\":\"bytes4[]\"},{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"mintable\",\"type\":\"bool\"},{\"name\":\"timestamp\",\"type\":\"uint256\"},{\"name\":\"price\",\"type\":\"uint256\"},{\"name\":\"contenthash\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_token\",\"type\":\"address\"}],\"name\":\"claimTokens\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_packId\",\"type\":\"uint256\"},{\"name\":\"_category\",\"type\":\"bytes4\"}],\"name\":\"removePackCategory\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"controller\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"packId\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"dataPrice\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"contenthash\",\"type\":\"bytes\"},{\"indexed\":false,\"name\":\"mintable\",\"type\":\"bool\"}],\"name\":\"Register\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"packId\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"dataPrice\",\"type\":\"uint256\"}],\"name\":\"PriceChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"packId\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"mintable\",\"type\":\"bool\"}],\"name\":\"MintabilityChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"packid\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"contenthash\",\"type\":\"bytes\"}],\"name\":\"ContenthashChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"category\",\"type\":\"bytes4\"},{\"indexed\":true,\"name\":\"packId\",\"type\":\"uint256\"}],\"name\":\"Categorized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"category\",\"type\":\"bytes4\"},{\"indexed\":true,\"name\":\"packId\",\"type\":\"uint256\"}],\"name\":\"Uncategorized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"packId\",\"type\":\"uint256\"}],\"name\":\"Unregister\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"approved\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"_token\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"_controller\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"ClaimedTokens\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"controller\",\"type\":\"address\"}],\"name\":\"NewController\",\"type\":\"event\"}]"
|
|
|
|
// StickerTypeFuncSigs maps the 4-byte function signature to its string representation.
|
|
var StickerTypeFuncSigs = map[string]string{
|
|
"aeeaf3da": "addPackCategory(uint256,bytes4)",
|
|
"095ea7b3": "approve(address,uint256)",
|
|
"70a08231": "balanceOf(address)",
|
|
"3cebb823": "changeController(address)",
|
|
"df8de3e7": "claimTokens(address)",
|
|
"f77c4791": "controller()",
|
|
"4c06dc17": "generatePack(uint256,uint256,bytes4[],address,bytes)",
|
|
"081812fc": "getApproved(uint256)",
|
|
"b34b5825": "getAvailablePacks(bytes4)",
|
|
"9f9a9b63": "getCategoryLength(bytes4)",
|
|
"b5420d68": "getCategoryPack(bytes4,uint256)",
|
|
"d2bf36c0": "getPackData(uint256)",
|
|
"81ec792d": "getPackSummary(uint256)",
|
|
"9c3a39a2": "getPaymentData(uint256)",
|
|
"e985e9c5": "isApprovedForAll(address,address)",
|
|
"06fdde03": "name()",
|
|
"6352211e": "ownerOf(uint256)",
|
|
"61bd6725": "packCount()",
|
|
"b84c1392": "packs(uint256)",
|
|
"00b3c91b": "purgePack(uint256,uint256)",
|
|
"e8bb7143": "removePackCategory(uint256,bytes4)",
|
|
"42842e0e": "safeTransferFrom(address,address,uint256)",
|
|
"b88d4fde": "safeTransferFrom(address,address,uint256,bytes)",
|
|
"a22cb465": "setApprovalForAll(address,bool)",
|
|
"6a847981": "setPackContenthash(uint256,bytes)",
|
|
"9389c5b5": "setPackPrice(uint256,uint256,uint256)",
|
|
"b7f48211": "setPackState(uint256,bool)",
|
|
"01ffc9a7": "supportsInterface(bytes4)",
|
|
"95d89b41": "symbol()",
|
|
"4f6ccce7": "tokenByIndex(uint256)",
|
|
"2f745c59": "tokenOfOwnerByIndex(address,uint256)",
|
|
"c87b56dd": "tokenURI(uint256)",
|
|
"18160ddd": "totalSupply()",
|
|
"23b872dd": "transferFrom(address,address,uint256)",
|
|
}
|
|
|
|
// StickerType is an auto generated Go binding around an Ethereum contract.
|
|
type StickerType struct {
|
|
StickerTypeCaller // Read-only binding to the contract
|
|
StickerTypeTransactor // Write-only binding to the contract
|
|
StickerTypeFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// StickerTypeCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type StickerTypeCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// StickerTypeTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type StickerTypeTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// StickerTypeFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type StickerTypeFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// StickerTypeSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type StickerTypeSession struct {
|
|
Contract *StickerType // 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
|
|
}
|
|
|
|
// StickerTypeCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type StickerTypeCallerSession struct {
|
|
Contract *StickerTypeCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// StickerTypeTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type StickerTypeTransactorSession struct {
|
|
Contract *StickerTypeTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// StickerTypeRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type StickerTypeRaw struct {
|
|
Contract *StickerType // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// StickerTypeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type StickerTypeCallerRaw struct {
|
|
Contract *StickerTypeCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// StickerTypeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type StickerTypeTransactorRaw struct {
|
|
Contract *StickerTypeTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewStickerType creates a new instance of StickerType, bound to a specific deployed contract.
|
|
func NewStickerType(address common.Address, backend bind.ContractBackend) (*StickerType, error) {
|
|
contract, err := bindStickerType(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerType{StickerTypeCaller: StickerTypeCaller{contract: contract}, StickerTypeTransactor: StickerTypeTransactor{contract: contract}, StickerTypeFilterer: StickerTypeFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewStickerTypeCaller creates a new read-only instance of StickerType, bound to a specific deployed contract.
|
|
func NewStickerTypeCaller(address common.Address, caller bind.ContractCaller) (*StickerTypeCaller, error) {
|
|
contract, err := bindStickerType(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerTypeCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewStickerTypeTransactor creates a new write-only instance of StickerType, bound to a specific deployed contract.
|
|
func NewStickerTypeTransactor(address common.Address, transactor bind.ContractTransactor) (*StickerTypeTransactor, error) {
|
|
contract, err := bindStickerType(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerTypeTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewStickerTypeFilterer creates a new log filterer instance of StickerType, bound to a specific deployed contract.
|
|
func NewStickerTypeFilterer(address common.Address, filterer bind.ContractFilterer) (*StickerTypeFilterer, error) {
|
|
contract, err := bindStickerType(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerTypeFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindStickerType binds a generic wrapper to an already deployed contract.
|
|
func bindStickerType(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(StickerTypeABI))
|
|
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 (_StickerType *StickerTypeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _StickerType.Contract.StickerTypeCaller.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 (_StickerType *StickerTypeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _StickerType.Contract.StickerTypeTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_StickerType *StickerTypeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _StickerType.Contract.StickerTypeTransactor.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 (_StickerType *StickerTypeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _StickerType.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 (_StickerType *StickerTypeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _StickerType.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_StickerType *StickerTypeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _StickerType.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address owner) view returns(uint256)
|
|
func (_StickerType *StickerTypeCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _StickerType.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 (_StickerType *StickerTypeSession) BalanceOf(owner common.Address) (*big.Int, error) {
|
|
return _StickerType.Contract.BalanceOf(&_StickerType.CallOpts, owner)
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address owner) view returns(uint256)
|
|
func (_StickerType *StickerTypeCallerSession) BalanceOf(owner common.Address) (*big.Int, error) {
|
|
return _StickerType.Contract.BalanceOf(&_StickerType.CallOpts, owner)
|
|
}
|
|
|
|
// Controller is a free data retrieval call binding the contract method 0xf77c4791.
|
|
//
|
|
// Solidity: function controller() view returns(address)
|
|
func (_StickerType *StickerTypeCaller) Controller(opts *bind.CallOpts) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _StickerType.contract.Call(opts, &out, "controller")
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Controller is a free data retrieval call binding the contract method 0xf77c4791.
|
|
//
|
|
// Solidity: function controller() view returns(address)
|
|
func (_StickerType *StickerTypeSession) Controller() (common.Address, error) {
|
|
return _StickerType.Contract.Controller(&_StickerType.CallOpts)
|
|
}
|
|
|
|
// Controller is a free data retrieval call binding the contract method 0xf77c4791.
|
|
//
|
|
// Solidity: function controller() view returns(address)
|
|
func (_StickerType *StickerTypeCallerSession) Controller() (common.Address, error) {
|
|
return _StickerType.Contract.Controller(&_StickerType.CallOpts)
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address)
|
|
func (_StickerType *StickerTypeCaller) GetApproved(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _StickerType.contract.Call(opts, &out, "getApproved", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address)
|
|
func (_StickerType *StickerTypeSession) GetApproved(tokenId *big.Int) (common.Address, error) {
|
|
return _StickerType.Contract.GetApproved(&_StickerType.CallOpts, tokenId)
|
|
}
|
|
|
|
// GetApproved is a free data retrieval call binding the contract method 0x081812fc.
|
|
//
|
|
// Solidity: function getApproved(uint256 tokenId) view returns(address)
|
|
func (_StickerType *StickerTypeCallerSession) GetApproved(tokenId *big.Int) (common.Address, error) {
|
|
return _StickerType.Contract.GetApproved(&_StickerType.CallOpts, tokenId)
|
|
}
|
|
|
|
// GetAvailablePacks is a free data retrieval call binding the contract method 0xb34b5825.
|
|
//
|
|
// Solidity: function getAvailablePacks(bytes4 _category) view returns(uint256[] availableIds)
|
|
func (_StickerType *StickerTypeCaller) GetAvailablePacks(opts *bind.CallOpts, _category [4]byte) ([]*big.Int, error) {
|
|
var out []interface{}
|
|
err := _StickerType.contract.Call(opts, &out, "getAvailablePacks", _category)
|
|
|
|
if err != nil {
|
|
return *new([]*big.Int), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// GetAvailablePacks is a free data retrieval call binding the contract method 0xb34b5825.
|
|
//
|
|
// Solidity: function getAvailablePacks(bytes4 _category) view returns(uint256[] availableIds)
|
|
func (_StickerType *StickerTypeSession) GetAvailablePacks(_category [4]byte) ([]*big.Int, error) {
|
|
return _StickerType.Contract.GetAvailablePacks(&_StickerType.CallOpts, _category)
|
|
}
|
|
|
|
// GetAvailablePacks is a free data retrieval call binding the contract method 0xb34b5825.
|
|
//
|
|
// Solidity: function getAvailablePacks(bytes4 _category) view returns(uint256[] availableIds)
|
|
func (_StickerType *StickerTypeCallerSession) GetAvailablePacks(_category [4]byte) ([]*big.Int, error) {
|
|
return _StickerType.Contract.GetAvailablePacks(&_StickerType.CallOpts, _category)
|
|
}
|
|
|
|
// GetCategoryLength is a free data retrieval call binding the contract method 0x9f9a9b63.
|
|
//
|
|
// Solidity: function getCategoryLength(bytes4 _category) view returns(uint256 size)
|
|
func (_StickerType *StickerTypeCaller) GetCategoryLength(opts *bind.CallOpts, _category [4]byte) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _StickerType.contract.Call(opts, &out, "getCategoryLength", _category)
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// GetCategoryLength is a free data retrieval call binding the contract method 0x9f9a9b63.
|
|
//
|
|
// Solidity: function getCategoryLength(bytes4 _category) view returns(uint256 size)
|
|
func (_StickerType *StickerTypeSession) GetCategoryLength(_category [4]byte) (*big.Int, error) {
|
|
return _StickerType.Contract.GetCategoryLength(&_StickerType.CallOpts, _category)
|
|
}
|
|
|
|
// GetCategoryLength is a free data retrieval call binding the contract method 0x9f9a9b63.
|
|
//
|
|
// Solidity: function getCategoryLength(bytes4 _category) view returns(uint256 size)
|
|
func (_StickerType *StickerTypeCallerSession) GetCategoryLength(_category [4]byte) (*big.Int, error) {
|
|
return _StickerType.Contract.GetCategoryLength(&_StickerType.CallOpts, _category)
|
|
}
|
|
|
|
// GetCategoryPack is a free data retrieval call binding the contract method 0xb5420d68.
|
|
//
|
|
// Solidity: function getCategoryPack(bytes4 _category, uint256 _index) view returns(uint256 packId)
|
|
func (_StickerType *StickerTypeCaller) GetCategoryPack(opts *bind.CallOpts, _category [4]byte, _index *big.Int) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _StickerType.contract.Call(opts, &out, "getCategoryPack", _category, _index)
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// GetCategoryPack is a free data retrieval call binding the contract method 0xb5420d68.
|
|
//
|
|
// Solidity: function getCategoryPack(bytes4 _category, uint256 _index) view returns(uint256 packId)
|
|
func (_StickerType *StickerTypeSession) GetCategoryPack(_category [4]byte, _index *big.Int) (*big.Int, error) {
|
|
return _StickerType.Contract.GetCategoryPack(&_StickerType.CallOpts, _category, _index)
|
|
}
|
|
|
|
// GetCategoryPack is a free data retrieval call binding the contract method 0xb5420d68.
|
|
//
|
|
// Solidity: function getCategoryPack(bytes4 _category, uint256 _index) view returns(uint256 packId)
|
|
func (_StickerType *StickerTypeCallerSession) GetCategoryPack(_category [4]byte, _index *big.Int) (*big.Int, error) {
|
|
return _StickerType.Contract.GetCategoryPack(&_StickerType.CallOpts, _category, _index)
|
|
}
|
|
|
|
// GetPackData is a free data retrieval call binding the contract method 0xd2bf36c0.
|
|
//
|
|
// Solidity: function getPackData(uint256 _packId) view returns(bytes4[] category, address owner, bool mintable, uint256 timestamp, uint256 price, bytes contenthash)
|
|
func (_StickerType *StickerTypeCaller) GetPackData(opts *bind.CallOpts, _packId *big.Int) (struct {
|
|
Category [][4]byte
|
|
Owner common.Address
|
|
Mintable bool
|
|
Timestamp *big.Int
|
|
Price *big.Int
|
|
Contenthash []byte
|
|
}, error) {
|
|
var out []interface{}
|
|
err := _StickerType.contract.Call(opts, &out, "getPackData", _packId)
|
|
|
|
outstruct := new(struct {
|
|
Category [][4]byte
|
|
Owner common.Address
|
|
Mintable bool
|
|
Timestamp *big.Int
|
|
Price *big.Int
|
|
Contenthash []byte
|
|
})
|
|
if err != nil {
|
|
return *outstruct, err
|
|
}
|
|
|
|
outstruct.Category = *abi.ConvertType(out[0], new([][4]byte)).(*[][4]byte)
|
|
outstruct.Owner = *abi.ConvertType(out[1], new(common.Address)).(*common.Address)
|
|
outstruct.Mintable = *abi.ConvertType(out[2], new(bool)).(*bool)
|
|
outstruct.Timestamp = *abi.ConvertType(out[3], new(*big.Int)).(**big.Int)
|
|
outstruct.Price = *abi.ConvertType(out[4], new(*big.Int)).(**big.Int)
|
|
outstruct.Contenthash = *abi.ConvertType(out[5], new([]byte)).(*[]byte)
|
|
|
|
return *outstruct, err
|
|
|
|
}
|
|
|
|
// GetPackData is a free data retrieval call binding the contract method 0xd2bf36c0.
|
|
//
|
|
// Solidity: function getPackData(uint256 _packId) view returns(bytes4[] category, address owner, bool mintable, uint256 timestamp, uint256 price, bytes contenthash)
|
|
func (_StickerType *StickerTypeSession) GetPackData(_packId *big.Int) (struct {
|
|
Category [][4]byte
|
|
Owner common.Address
|
|
Mintable bool
|
|
Timestamp *big.Int
|
|
Price *big.Int
|
|
Contenthash []byte
|
|
}, error) {
|
|
return _StickerType.Contract.GetPackData(&_StickerType.CallOpts, _packId)
|
|
}
|
|
|
|
// GetPackData is a free data retrieval call binding the contract method 0xd2bf36c0.
|
|
//
|
|
// Solidity: function getPackData(uint256 _packId) view returns(bytes4[] category, address owner, bool mintable, uint256 timestamp, uint256 price, bytes contenthash)
|
|
func (_StickerType *StickerTypeCallerSession) GetPackData(_packId *big.Int) (struct {
|
|
Category [][4]byte
|
|
Owner common.Address
|
|
Mintable bool
|
|
Timestamp *big.Int
|
|
Price *big.Int
|
|
Contenthash []byte
|
|
}, error) {
|
|
return _StickerType.Contract.GetPackData(&_StickerType.CallOpts, _packId)
|
|
}
|
|
|
|
// GetPackSummary is a free data retrieval call binding the contract method 0x81ec792d.
|
|
//
|
|
// Solidity: function getPackSummary(uint256 _packId) view returns(bytes4[] category, uint256 timestamp, bytes contenthash)
|
|
func (_StickerType *StickerTypeCaller) GetPackSummary(opts *bind.CallOpts, _packId *big.Int) (struct {
|
|
Category [][4]byte
|
|
Timestamp *big.Int
|
|
Contenthash []byte
|
|
}, error) {
|
|
var out []interface{}
|
|
err := _StickerType.contract.Call(opts, &out, "getPackSummary", _packId)
|
|
|
|
outstruct := new(struct {
|
|
Category [][4]byte
|
|
Timestamp *big.Int
|
|
Contenthash []byte
|
|
})
|
|
if err != nil {
|
|
return *outstruct, err
|
|
}
|
|
|
|
outstruct.Category = *abi.ConvertType(out[0], new([][4]byte)).(*[][4]byte)
|
|
outstruct.Timestamp = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int)
|
|
outstruct.Contenthash = *abi.ConvertType(out[2], new([]byte)).(*[]byte)
|
|
|
|
return *outstruct, err
|
|
|
|
}
|
|
|
|
// GetPackSummary is a free data retrieval call binding the contract method 0x81ec792d.
|
|
//
|
|
// Solidity: function getPackSummary(uint256 _packId) view returns(bytes4[] category, uint256 timestamp, bytes contenthash)
|
|
func (_StickerType *StickerTypeSession) GetPackSummary(_packId *big.Int) (struct {
|
|
Category [][4]byte
|
|
Timestamp *big.Int
|
|
Contenthash []byte
|
|
}, error) {
|
|
return _StickerType.Contract.GetPackSummary(&_StickerType.CallOpts, _packId)
|
|
}
|
|
|
|
// GetPackSummary is a free data retrieval call binding the contract method 0x81ec792d.
|
|
//
|
|
// Solidity: function getPackSummary(uint256 _packId) view returns(bytes4[] category, uint256 timestamp, bytes contenthash)
|
|
func (_StickerType *StickerTypeCallerSession) GetPackSummary(_packId *big.Int) (struct {
|
|
Category [][4]byte
|
|
Timestamp *big.Int
|
|
Contenthash []byte
|
|
}, error) {
|
|
return _StickerType.Contract.GetPackSummary(&_StickerType.CallOpts, _packId)
|
|
}
|
|
|
|
// GetPaymentData is a free data retrieval call binding the contract method 0x9c3a39a2.
|
|
//
|
|
// Solidity: function getPaymentData(uint256 _packId) view returns(address owner, bool mintable, uint256 price, uint256 donate)
|
|
func (_StickerType *StickerTypeCaller) GetPaymentData(opts *bind.CallOpts, _packId *big.Int) (struct {
|
|
Owner common.Address
|
|
Mintable bool
|
|
Price *big.Int
|
|
Donate *big.Int
|
|
}, error) {
|
|
var out []interface{}
|
|
err := _StickerType.contract.Call(opts, &out, "getPaymentData", _packId)
|
|
|
|
outstruct := new(struct {
|
|
Owner common.Address
|
|
Mintable bool
|
|
Price *big.Int
|
|
Donate *big.Int
|
|
})
|
|
if err != nil {
|
|
return *outstruct, err
|
|
}
|
|
|
|
outstruct.Owner = *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
outstruct.Mintable = *abi.ConvertType(out[1], new(bool)).(*bool)
|
|
outstruct.Price = *abi.ConvertType(out[2], new(*big.Int)).(**big.Int)
|
|
outstruct.Donate = *abi.ConvertType(out[3], new(*big.Int)).(**big.Int)
|
|
|
|
return *outstruct, err
|
|
|
|
}
|
|
|
|
// GetPaymentData is a free data retrieval call binding the contract method 0x9c3a39a2.
|
|
//
|
|
// Solidity: function getPaymentData(uint256 _packId) view returns(address owner, bool mintable, uint256 price, uint256 donate)
|
|
func (_StickerType *StickerTypeSession) GetPaymentData(_packId *big.Int) (struct {
|
|
Owner common.Address
|
|
Mintable bool
|
|
Price *big.Int
|
|
Donate *big.Int
|
|
}, error) {
|
|
return _StickerType.Contract.GetPaymentData(&_StickerType.CallOpts, _packId)
|
|
}
|
|
|
|
// GetPaymentData is a free data retrieval call binding the contract method 0x9c3a39a2.
|
|
//
|
|
// Solidity: function getPaymentData(uint256 _packId) view returns(address owner, bool mintable, uint256 price, uint256 donate)
|
|
func (_StickerType *StickerTypeCallerSession) GetPaymentData(_packId *big.Int) (struct {
|
|
Owner common.Address
|
|
Mintable bool
|
|
Price *big.Int
|
|
Donate *big.Int
|
|
}, error) {
|
|
return _StickerType.Contract.GetPaymentData(&_StickerType.CallOpts, _packId)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_StickerType *StickerTypeCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error) {
|
|
var out []interface{}
|
|
err := _StickerType.contract.Call(opts, &out, "isApprovedForAll", owner, operator)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_StickerType *StickerTypeSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _StickerType.Contract.IsApprovedForAll(&_StickerType.CallOpts, owner, operator)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_StickerType *StickerTypeCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _StickerType.Contract.IsApprovedForAll(&_StickerType.CallOpts, owner, operator)
|
|
}
|
|
|
|
// Name is a free data retrieval call binding the contract method 0x06fdde03.
|
|
//
|
|
// Solidity: function name() view returns(string)
|
|
func (_StickerType *StickerTypeCaller) Name(opts *bind.CallOpts) (string, error) {
|
|
var out []interface{}
|
|
err := _StickerType.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 (_StickerType *StickerTypeSession) Name() (string, error) {
|
|
return _StickerType.Contract.Name(&_StickerType.CallOpts)
|
|
}
|
|
|
|
// Name is a free data retrieval call binding the contract method 0x06fdde03.
|
|
//
|
|
// Solidity: function name() view returns(string)
|
|
func (_StickerType *StickerTypeCallerSession) Name() (string, error) {
|
|
return _StickerType.Contract.Name(&_StickerType.CallOpts)
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address)
|
|
func (_StickerType *StickerTypeCaller) OwnerOf(opts *bind.CallOpts, tokenId *big.Int) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _StickerType.contract.Call(opts, &out, "ownerOf", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address)
|
|
func (_StickerType *StickerTypeSession) OwnerOf(tokenId *big.Int) (common.Address, error) {
|
|
return _StickerType.Contract.OwnerOf(&_StickerType.CallOpts, tokenId)
|
|
}
|
|
|
|
// OwnerOf is a free data retrieval call binding the contract method 0x6352211e.
|
|
//
|
|
// Solidity: function ownerOf(uint256 tokenId) view returns(address)
|
|
func (_StickerType *StickerTypeCallerSession) OwnerOf(tokenId *big.Int) (common.Address, error) {
|
|
return _StickerType.Contract.OwnerOf(&_StickerType.CallOpts, tokenId)
|
|
}
|
|
|
|
// PackCount is a free data retrieval call binding the contract method 0x61bd6725.
|
|
//
|
|
// Solidity: function packCount() view returns(uint256)
|
|
func (_StickerType *StickerTypeCaller) PackCount(opts *bind.CallOpts) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _StickerType.contract.Call(opts, &out, "packCount")
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// PackCount is a free data retrieval call binding the contract method 0x61bd6725.
|
|
//
|
|
// Solidity: function packCount() view returns(uint256)
|
|
func (_StickerType *StickerTypeSession) PackCount() (*big.Int, error) {
|
|
return _StickerType.Contract.PackCount(&_StickerType.CallOpts)
|
|
}
|
|
|
|
// PackCount is a free data retrieval call binding the contract method 0x61bd6725.
|
|
//
|
|
// Solidity: function packCount() view returns(uint256)
|
|
func (_StickerType *StickerTypeCallerSession) PackCount() (*big.Int, error) {
|
|
return _StickerType.Contract.PackCount(&_StickerType.CallOpts)
|
|
}
|
|
|
|
// Packs is a free data retrieval call binding the contract method 0xb84c1392.
|
|
//
|
|
// Solidity: function packs(uint256 ) view returns(bool mintable, uint256 timestamp, uint256 price, uint256 donate, bytes contenthash)
|
|
func (_StickerType *StickerTypeCaller) Packs(opts *bind.CallOpts, arg0 *big.Int) (struct {
|
|
Mintable bool
|
|
Timestamp *big.Int
|
|
Price *big.Int
|
|
Donate *big.Int
|
|
Contenthash []byte
|
|
}, error) {
|
|
var out []interface{}
|
|
err := _StickerType.contract.Call(opts, &out, "packs", arg0)
|
|
|
|
outstruct := new(struct {
|
|
Mintable bool
|
|
Timestamp *big.Int
|
|
Price *big.Int
|
|
Donate *big.Int
|
|
Contenthash []byte
|
|
})
|
|
if err != nil {
|
|
return *outstruct, err
|
|
}
|
|
|
|
outstruct.Mintable = *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
outstruct.Timestamp = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int)
|
|
outstruct.Price = *abi.ConvertType(out[2], new(*big.Int)).(**big.Int)
|
|
outstruct.Donate = *abi.ConvertType(out[3], new(*big.Int)).(**big.Int)
|
|
outstruct.Contenthash = *abi.ConvertType(out[4], new([]byte)).(*[]byte)
|
|
|
|
return *outstruct, err
|
|
|
|
}
|
|
|
|
// Packs is a free data retrieval call binding the contract method 0xb84c1392.
|
|
//
|
|
// Solidity: function packs(uint256 ) view returns(bool mintable, uint256 timestamp, uint256 price, uint256 donate, bytes contenthash)
|
|
func (_StickerType *StickerTypeSession) Packs(arg0 *big.Int) (struct {
|
|
Mintable bool
|
|
Timestamp *big.Int
|
|
Price *big.Int
|
|
Donate *big.Int
|
|
Contenthash []byte
|
|
}, error) {
|
|
return _StickerType.Contract.Packs(&_StickerType.CallOpts, arg0)
|
|
}
|
|
|
|
// Packs is a free data retrieval call binding the contract method 0xb84c1392.
|
|
//
|
|
// Solidity: function packs(uint256 ) view returns(bool mintable, uint256 timestamp, uint256 price, uint256 donate, bytes contenthash)
|
|
func (_StickerType *StickerTypeCallerSession) Packs(arg0 *big.Int) (struct {
|
|
Mintable bool
|
|
Timestamp *big.Int
|
|
Price *big.Int
|
|
Donate *big.Int
|
|
Contenthash []byte
|
|
}, error) {
|
|
return _StickerType.Contract.Packs(&_StickerType.CallOpts, arg0)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_StickerType *StickerTypeCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _StickerType.contract.Call(opts, &out, "supportsInterface", interfaceId)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_StickerType *StickerTypeSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _StickerType.Contract.SupportsInterface(&_StickerType.CallOpts, interfaceId)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)
|
|
func (_StickerType *StickerTypeCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
|
|
return _StickerType.Contract.SupportsInterface(&_StickerType.CallOpts, interfaceId)
|
|
}
|
|
|
|
// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
|
|
//
|
|
// Solidity: function symbol() view returns(string)
|
|
func (_StickerType *StickerTypeCaller) Symbol(opts *bind.CallOpts) (string, error) {
|
|
var out []interface{}
|
|
err := _StickerType.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 (_StickerType *StickerTypeSession) Symbol() (string, error) {
|
|
return _StickerType.Contract.Symbol(&_StickerType.CallOpts)
|
|
}
|
|
|
|
// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
|
|
//
|
|
// Solidity: function symbol() view returns(string)
|
|
func (_StickerType *StickerTypeCallerSession) Symbol() (string, error) {
|
|
return _StickerType.Contract.Symbol(&_StickerType.CallOpts)
|
|
}
|
|
|
|
// TokenByIndex is a free data retrieval call binding the contract method 0x4f6ccce7.
|
|
//
|
|
// Solidity: function tokenByIndex(uint256 index) view returns(uint256)
|
|
func (_StickerType *StickerTypeCaller) TokenByIndex(opts *bind.CallOpts, index *big.Int) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _StickerType.contract.Call(opts, &out, "tokenByIndex", index)
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// TokenByIndex is a free data retrieval call binding the contract method 0x4f6ccce7.
|
|
//
|
|
// Solidity: function tokenByIndex(uint256 index) view returns(uint256)
|
|
func (_StickerType *StickerTypeSession) TokenByIndex(index *big.Int) (*big.Int, error) {
|
|
return _StickerType.Contract.TokenByIndex(&_StickerType.CallOpts, index)
|
|
}
|
|
|
|
// TokenByIndex is a free data retrieval call binding the contract method 0x4f6ccce7.
|
|
//
|
|
// Solidity: function tokenByIndex(uint256 index) view returns(uint256)
|
|
func (_StickerType *StickerTypeCallerSession) TokenByIndex(index *big.Int) (*big.Int, error) {
|
|
return _StickerType.Contract.TokenByIndex(&_StickerType.CallOpts, index)
|
|
}
|
|
|
|
// TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59.
|
|
//
|
|
// Solidity: function tokenOfOwnerByIndex(address owner, uint256 index) view returns(uint256)
|
|
func (_StickerType *StickerTypeCaller) TokenOfOwnerByIndex(opts *bind.CallOpts, owner common.Address, index *big.Int) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _StickerType.contract.Call(opts, &out, "tokenOfOwnerByIndex", owner, index)
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59.
|
|
//
|
|
// Solidity: function tokenOfOwnerByIndex(address owner, uint256 index) view returns(uint256)
|
|
func (_StickerType *StickerTypeSession) TokenOfOwnerByIndex(owner common.Address, index *big.Int) (*big.Int, error) {
|
|
return _StickerType.Contract.TokenOfOwnerByIndex(&_StickerType.CallOpts, owner, index)
|
|
}
|
|
|
|
// TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59.
|
|
//
|
|
// Solidity: function tokenOfOwnerByIndex(address owner, uint256 index) view returns(uint256)
|
|
func (_StickerType *StickerTypeCallerSession) TokenOfOwnerByIndex(owner common.Address, index *big.Int) (*big.Int, error) {
|
|
return _StickerType.Contract.TokenOfOwnerByIndex(&_StickerType.CallOpts, owner, index)
|
|
}
|
|
|
|
// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd.
|
|
//
|
|
// Solidity: function tokenURI(uint256 tokenId) view returns(string)
|
|
func (_StickerType *StickerTypeCaller) TokenURI(opts *bind.CallOpts, tokenId *big.Int) (string, error) {
|
|
var out []interface{}
|
|
err := _StickerType.contract.Call(opts, &out, "tokenURI", tokenId)
|
|
|
|
if err != nil {
|
|
return *new(string), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(string)).(*string)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd.
|
|
//
|
|
// Solidity: function tokenURI(uint256 tokenId) view returns(string)
|
|
func (_StickerType *StickerTypeSession) TokenURI(tokenId *big.Int) (string, error) {
|
|
return _StickerType.Contract.TokenURI(&_StickerType.CallOpts, tokenId)
|
|
}
|
|
|
|
// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd.
|
|
//
|
|
// Solidity: function tokenURI(uint256 tokenId) view returns(string)
|
|
func (_StickerType *StickerTypeCallerSession) TokenURI(tokenId *big.Int) (string, error) {
|
|
return _StickerType.Contract.TokenURI(&_StickerType.CallOpts, tokenId)
|
|
}
|
|
|
|
// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
|
|
//
|
|
// Solidity: function totalSupply() view returns(uint256)
|
|
func (_StickerType *StickerTypeCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _StickerType.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 (_StickerType *StickerTypeSession) TotalSupply() (*big.Int, error) {
|
|
return _StickerType.Contract.TotalSupply(&_StickerType.CallOpts)
|
|
}
|
|
|
|
// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
|
|
//
|
|
// Solidity: function totalSupply() view returns(uint256)
|
|
func (_StickerType *StickerTypeCallerSession) TotalSupply() (*big.Int, error) {
|
|
return _StickerType.Contract.TotalSupply(&_StickerType.CallOpts)
|
|
}
|
|
|
|
// AddPackCategory is a paid mutator transaction binding the contract method 0xaeeaf3da.
|
|
//
|
|
// Solidity: function addPackCategory(uint256 _packId, bytes4 _category) returns()
|
|
func (_StickerType *StickerTypeTransactor) AddPackCategory(opts *bind.TransactOpts, _packId *big.Int, _category [4]byte) (*types.Transaction, error) {
|
|
return _StickerType.contract.Transact(opts, "addPackCategory", _packId, _category)
|
|
}
|
|
|
|
// AddPackCategory is a paid mutator transaction binding the contract method 0xaeeaf3da.
|
|
//
|
|
// Solidity: function addPackCategory(uint256 _packId, bytes4 _category) returns()
|
|
func (_StickerType *StickerTypeSession) AddPackCategory(_packId *big.Int, _category [4]byte) (*types.Transaction, error) {
|
|
return _StickerType.Contract.AddPackCategory(&_StickerType.TransactOpts, _packId, _category)
|
|
}
|
|
|
|
// AddPackCategory is a paid mutator transaction binding the contract method 0xaeeaf3da.
|
|
//
|
|
// Solidity: function addPackCategory(uint256 _packId, bytes4 _category) returns()
|
|
func (_StickerType *StickerTypeTransactorSession) AddPackCategory(_packId *big.Int, _category [4]byte) (*types.Transaction, error) {
|
|
return _StickerType.Contract.AddPackCategory(&_StickerType.TransactOpts, _packId, _category)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_StickerType *StickerTypeTransactor) Approve(opts *bind.TransactOpts, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _StickerType.contract.Transact(opts, "approve", to, tokenId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_StickerType *StickerTypeSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _StickerType.Contract.Approve(&_StickerType.TransactOpts, to, tokenId)
|
|
}
|
|
|
|
// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
|
|
//
|
|
// Solidity: function approve(address to, uint256 tokenId) returns()
|
|
func (_StickerType *StickerTypeTransactorSession) Approve(to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _StickerType.Contract.Approve(&_StickerType.TransactOpts, to, tokenId)
|
|
}
|
|
|
|
// ChangeController is a paid mutator transaction binding the contract method 0x3cebb823.
|
|
//
|
|
// Solidity: function changeController(address _newController) returns()
|
|
func (_StickerType *StickerTypeTransactor) ChangeController(opts *bind.TransactOpts, _newController common.Address) (*types.Transaction, error) {
|
|
return _StickerType.contract.Transact(opts, "changeController", _newController)
|
|
}
|
|
|
|
// ChangeController is a paid mutator transaction binding the contract method 0x3cebb823.
|
|
//
|
|
// Solidity: function changeController(address _newController) returns()
|
|
func (_StickerType *StickerTypeSession) ChangeController(_newController common.Address) (*types.Transaction, error) {
|
|
return _StickerType.Contract.ChangeController(&_StickerType.TransactOpts, _newController)
|
|
}
|
|
|
|
// ChangeController is a paid mutator transaction binding the contract method 0x3cebb823.
|
|
//
|
|
// Solidity: function changeController(address _newController) returns()
|
|
func (_StickerType *StickerTypeTransactorSession) ChangeController(_newController common.Address) (*types.Transaction, error) {
|
|
return _StickerType.Contract.ChangeController(&_StickerType.TransactOpts, _newController)
|
|
}
|
|
|
|
// ClaimTokens is a paid mutator transaction binding the contract method 0xdf8de3e7.
|
|
//
|
|
// Solidity: function claimTokens(address _token) returns()
|
|
func (_StickerType *StickerTypeTransactor) ClaimTokens(opts *bind.TransactOpts, _token common.Address) (*types.Transaction, error) {
|
|
return _StickerType.contract.Transact(opts, "claimTokens", _token)
|
|
}
|
|
|
|
// ClaimTokens is a paid mutator transaction binding the contract method 0xdf8de3e7.
|
|
//
|
|
// Solidity: function claimTokens(address _token) returns()
|
|
func (_StickerType *StickerTypeSession) ClaimTokens(_token common.Address) (*types.Transaction, error) {
|
|
return _StickerType.Contract.ClaimTokens(&_StickerType.TransactOpts, _token)
|
|
}
|
|
|
|
// ClaimTokens is a paid mutator transaction binding the contract method 0xdf8de3e7.
|
|
//
|
|
// Solidity: function claimTokens(address _token) returns()
|
|
func (_StickerType *StickerTypeTransactorSession) ClaimTokens(_token common.Address) (*types.Transaction, error) {
|
|
return _StickerType.Contract.ClaimTokens(&_StickerType.TransactOpts, _token)
|
|
}
|
|
|
|
// GeneratePack is a paid mutator transaction binding the contract method 0x4c06dc17.
|
|
//
|
|
// Solidity: function generatePack(uint256 _price, uint256 _donate, bytes4[] _category, address _owner, bytes _contenthash) returns(uint256 packId)
|
|
func (_StickerType *StickerTypeTransactor) GeneratePack(opts *bind.TransactOpts, _price *big.Int, _donate *big.Int, _category [][4]byte, _owner common.Address, _contenthash []byte) (*types.Transaction, error) {
|
|
return _StickerType.contract.Transact(opts, "generatePack", _price, _donate, _category, _owner, _contenthash)
|
|
}
|
|
|
|
// GeneratePack is a paid mutator transaction binding the contract method 0x4c06dc17.
|
|
//
|
|
// Solidity: function generatePack(uint256 _price, uint256 _donate, bytes4[] _category, address _owner, bytes _contenthash) returns(uint256 packId)
|
|
func (_StickerType *StickerTypeSession) GeneratePack(_price *big.Int, _donate *big.Int, _category [][4]byte, _owner common.Address, _contenthash []byte) (*types.Transaction, error) {
|
|
return _StickerType.Contract.GeneratePack(&_StickerType.TransactOpts, _price, _donate, _category, _owner, _contenthash)
|
|
}
|
|
|
|
// GeneratePack is a paid mutator transaction binding the contract method 0x4c06dc17.
|
|
//
|
|
// Solidity: function generatePack(uint256 _price, uint256 _donate, bytes4[] _category, address _owner, bytes _contenthash) returns(uint256 packId)
|
|
func (_StickerType *StickerTypeTransactorSession) GeneratePack(_price *big.Int, _donate *big.Int, _category [][4]byte, _owner common.Address, _contenthash []byte) (*types.Transaction, error) {
|
|
return _StickerType.Contract.GeneratePack(&_StickerType.TransactOpts, _price, _donate, _category, _owner, _contenthash)
|
|
}
|
|
|
|
// PurgePack is a paid mutator transaction binding the contract method 0x00b3c91b.
|
|
//
|
|
// Solidity: function purgePack(uint256 _packId, uint256 _limit) returns()
|
|
func (_StickerType *StickerTypeTransactor) PurgePack(opts *bind.TransactOpts, _packId *big.Int, _limit *big.Int) (*types.Transaction, error) {
|
|
return _StickerType.contract.Transact(opts, "purgePack", _packId, _limit)
|
|
}
|
|
|
|
// PurgePack is a paid mutator transaction binding the contract method 0x00b3c91b.
|
|
//
|
|
// Solidity: function purgePack(uint256 _packId, uint256 _limit) returns()
|
|
func (_StickerType *StickerTypeSession) PurgePack(_packId *big.Int, _limit *big.Int) (*types.Transaction, error) {
|
|
return _StickerType.Contract.PurgePack(&_StickerType.TransactOpts, _packId, _limit)
|
|
}
|
|
|
|
// PurgePack is a paid mutator transaction binding the contract method 0x00b3c91b.
|
|
//
|
|
// Solidity: function purgePack(uint256 _packId, uint256 _limit) returns()
|
|
func (_StickerType *StickerTypeTransactorSession) PurgePack(_packId *big.Int, _limit *big.Int) (*types.Transaction, error) {
|
|
return _StickerType.Contract.PurgePack(&_StickerType.TransactOpts, _packId, _limit)
|
|
}
|
|
|
|
// RemovePackCategory is a paid mutator transaction binding the contract method 0xe8bb7143.
|
|
//
|
|
// Solidity: function removePackCategory(uint256 _packId, bytes4 _category) returns()
|
|
func (_StickerType *StickerTypeTransactor) RemovePackCategory(opts *bind.TransactOpts, _packId *big.Int, _category [4]byte) (*types.Transaction, error) {
|
|
return _StickerType.contract.Transact(opts, "removePackCategory", _packId, _category)
|
|
}
|
|
|
|
// RemovePackCategory is a paid mutator transaction binding the contract method 0xe8bb7143.
|
|
//
|
|
// Solidity: function removePackCategory(uint256 _packId, bytes4 _category) returns()
|
|
func (_StickerType *StickerTypeSession) RemovePackCategory(_packId *big.Int, _category [4]byte) (*types.Transaction, error) {
|
|
return _StickerType.Contract.RemovePackCategory(&_StickerType.TransactOpts, _packId, _category)
|
|
}
|
|
|
|
// RemovePackCategory is a paid mutator transaction binding the contract method 0xe8bb7143.
|
|
//
|
|
// Solidity: function removePackCategory(uint256 _packId, bytes4 _category) returns()
|
|
func (_StickerType *StickerTypeTransactorSession) RemovePackCategory(_packId *big.Int, _category [4]byte) (*types.Transaction, error) {
|
|
return _StickerType.Contract.RemovePackCategory(&_StickerType.TransactOpts, _packId, _category)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_StickerType *StickerTypeTransactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _StickerType.contract.Transact(opts, "safeTransferFrom", from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_StickerType *StickerTypeSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _StickerType.Contract.SafeTransferFrom(&_StickerType.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_StickerType *StickerTypeTransactorSession) SafeTransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _StickerType.Contract.SafeTransferFrom(&_StickerType.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes _data) returns()
|
|
func (_StickerType *StickerTypeTransactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error) {
|
|
return _StickerType.contract.Transact(opts, "safeTransferFrom0", from, to, tokenId, _data)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes _data) returns()
|
|
func (_StickerType *StickerTypeSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error) {
|
|
return _StickerType.Contract.SafeTransferFrom0(&_StickerType.TransactOpts, from, to, tokenId, _data)
|
|
}
|
|
|
|
// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde.
|
|
//
|
|
// Solidity: function safeTransferFrom(address from, address to, uint256 tokenId, bytes _data) returns()
|
|
func (_StickerType *StickerTypeTransactorSession) SafeTransferFrom0(from common.Address, to common.Address, tokenId *big.Int, _data []byte) (*types.Transaction, error) {
|
|
return _StickerType.Contract.SafeTransferFrom0(&_StickerType.TransactOpts, from, to, tokenId, _data)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address to, bool approved) returns()
|
|
func (_StickerType *StickerTypeTransactor) SetApprovalForAll(opts *bind.TransactOpts, to common.Address, approved bool) (*types.Transaction, error) {
|
|
return _StickerType.contract.Transact(opts, "setApprovalForAll", to, approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address to, bool approved) returns()
|
|
func (_StickerType *StickerTypeSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error) {
|
|
return _StickerType.Contract.SetApprovalForAll(&_StickerType.TransactOpts, to, approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address to, bool approved) returns()
|
|
func (_StickerType *StickerTypeTransactorSession) SetApprovalForAll(to common.Address, approved bool) (*types.Transaction, error) {
|
|
return _StickerType.Contract.SetApprovalForAll(&_StickerType.TransactOpts, to, approved)
|
|
}
|
|
|
|
// SetPackContenthash is a paid mutator transaction binding the contract method 0x6a847981.
|
|
//
|
|
// Solidity: function setPackContenthash(uint256 _packId, bytes _contenthash) returns()
|
|
func (_StickerType *StickerTypeTransactor) SetPackContenthash(opts *bind.TransactOpts, _packId *big.Int, _contenthash []byte) (*types.Transaction, error) {
|
|
return _StickerType.contract.Transact(opts, "setPackContenthash", _packId, _contenthash)
|
|
}
|
|
|
|
// SetPackContenthash is a paid mutator transaction binding the contract method 0x6a847981.
|
|
//
|
|
// Solidity: function setPackContenthash(uint256 _packId, bytes _contenthash) returns()
|
|
func (_StickerType *StickerTypeSession) SetPackContenthash(_packId *big.Int, _contenthash []byte) (*types.Transaction, error) {
|
|
return _StickerType.Contract.SetPackContenthash(&_StickerType.TransactOpts, _packId, _contenthash)
|
|
}
|
|
|
|
// SetPackContenthash is a paid mutator transaction binding the contract method 0x6a847981.
|
|
//
|
|
// Solidity: function setPackContenthash(uint256 _packId, bytes _contenthash) returns()
|
|
func (_StickerType *StickerTypeTransactorSession) SetPackContenthash(_packId *big.Int, _contenthash []byte) (*types.Transaction, error) {
|
|
return _StickerType.Contract.SetPackContenthash(&_StickerType.TransactOpts, _packId, _contenthash)
|
|
}
|
|
|
|
// SetPackPrice is a paid mutator transaction binding the contract method 0x9389c5b5.
|
|
//
|
|
// Solidity: function setPackPrice(uint256 _packId, uint256 _price, uint256 _donate) returns()
|
|
func (_StickerType *StickerTypeTransactor) SetPackPrice(opts *bind.TransactOpts, _packId *big.Int, _price *big.Int, _donate *big.Int) (*types.Transaction, error) {
|
|
return _StickerType.contract.Transact(opts, "setPackPrice", _packId, _price, _donate)
|
|
}
|
|
|
|
// SetPackPrice is a paid mutator transaction binding the contract method 0x9389c5b5.
|
|
//
|
|
// Solidity: function setPackPrice(uint256 _packId, uint256 _price, uint256 _donate) returns()
|
|
func (_StickerType *StickerTypeSession) SetPackPrice(_packId *big.Int, _price *big.Int, _donate *big.Int) (*types.Transaction, error) {
|
|
return _StickerType.Contract.SetPackPrice(&_StickerType.TransactOpts, _packId, _price, _donate)
|
|
}
|
|
|
|
// SetPackPrice is a paid mutator transaction binding the contract method 0x9389c5b5.
|
|
//
|
|
// Solidity: function setPackPrice(uint256 _packId, uint256 _price, uint256 _donate) returns()
|
|
func (_StickerType *StickerTypeTransactorSession) SetPackPrice(_packId *big.Int, _price *big.Int, _donate *big.Int) (*types.Transaction, error) {
|
|
return _StickerType.Contract.SetPackPrice(&_StickerType.TransactOpts, _packId, _price, _donate)
|
|
}
|
|
|
|
// SetPackState is a paid mutator transaction binding the contract method 0xb7f48211.
|
|
//
|
|
// Solidity: function setPackState(uint256 _packId, bool _mintable) returns()
|
|
func (_StickerType *StickerTypeTransactor) SetPackState(opts *bind.TransactOpts, _packId *big.Int, _mintable bool) (*types.Transaction, error) {
|
|
return _StickerType.contract.Transact(opts, "setPackState", _packId, _mintable)
|
|
}
|
|
|
|
// SetPackState is a paid mutator transaction binding the contract method 0xb7f48211.
|
|
//
|
|
// Solidity: function setPackState(uint256 _packId, bool _mintable) returns()
|
|
func (_StickerType *StickerTypeSession) SetPackState(_packId *big.Int, _mintable bool) (*types.Transaction, error) {
|
|
return _StickerType.Contract.SetPackState(&_StickerType.TransactOpts, _packId, _mintable)
|
|
}
|
|
|
|
// SetPackState is a paid mutator transaction binding the contract method 0xb7f48211.
|
|
//
|
|
// Solidity: function setPackState(uint256 _packId, bool _mintable) returns()
|
|
func (_StickerType *StickerTypeTransactorSession) SetPackState(_packId *big.Int, _mintable bool) (*types.Transaction, error) {
|
|
return _StickerType.Contract.SetPackState(&_StickerType.TransactOpts, _packId, _mintable)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_StickerType *StickerTypeTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _StickerType.contract.Transact(opts, "transferFrom", from, to, tokenId)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_StickerType *StickerTypeSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _StickerType.Contract.TransferFrom(&_StickerType.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
|
|
//
|
|
// Solidity: function transferFrom(address from, address to, uint256 tokenId) returns()
|
|
func (_StickerType *StickerTypeTransactorSession) TransferFrom(from common.Address, to common.Address, tokenId *big.Int) (*types.Transaction, error) {
|
|
return _StickerType.Contract.TransferFrom(&_StickerType.TransactOpts, from, to, tokenId)
|
|
}
|
|
|
|
// StickerTypeApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the StickerType contract.
|
|
type StickerTypeApprovalIterator struct {
|
|
Event *StickerTypeApproval // 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 *StickerTypeApprovalIterator) 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(StickerTypeApproval)
|
|
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(StickerTypeApproval)
|
|
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 *StickerTypeApprovalIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerTypeApprovalIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerTypeApproval represents a Approval event raised by the StickerType contract.
|
|
type StickerTypeApproval struct {
|
|
Owner common.Address
|
|
Approved common.Address
|
|
TokenId *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 approved, uint256 indexed tokenId)
|
|
func (_StickerType *StickerTypeFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, approved []common.Address, tokenId []*big.Int) (*StickerTypeApprovalIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var approvedRule []interface{}
|
|
for _, approvedItem := range approved {
|
|
approvedRule = append(approvedRule, approvedItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerType.contract.FilterLogs(opts, "Approval", ownerRule, approvedRule, tokenIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerTypeApprovalIterator{contract: _StickerType.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 approved, uint256 indexed tokenId)
|
|
func (_StickerType *StickerTypeFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *StickerTypeApproval, owner []common.Address, approved []common.Address, tokenId []*big.Int) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var approvedRule []interface{}
|
|
for _, approvedItem := range approved {
|
|
approvedRule = append(approvedRule, approvedItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerType.contract.WatchLogs(opts, "Approval", ownerRule, approvedRule, tokenIdRule)
|
|
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(StickerTypeApproval)
|
|
if err := _StickerType.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 approved, uint256 indexed tokenId)
|
|
func (_StickerType *StickerTypeFilterer) ParseApproval(log types.Log) (*StickerTypeApproval, error) {
|
|
event := new(StickerTypeApproval)
|
|
if err := _StickerType.contract.UnpackLog(event, "Approval", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerTypeApprovalForAllIterator is returned from FilterApprovalForAll and is used to iterate over the raw logs and unpacked data for ApprovalForAll events raised by the StickerType contract.
|
|
type StickerTypeApprovalForAllIterator struct {
|
|
Event *StickerTypeApprovalForAll // 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 *StickerTypeApprovalForAllIterator) 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(StickerTypeApprovalForAll)
|
|
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(StickerTypeApprovalForAll)
|
|
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 *StickerTypeApprovalForAllIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerTypeApprovalForAllIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerTypeApprovalForAll represents a ApprovalForAll event raised by the StickerType contract.
|
|
type StickerTypeApprovalForAll struct {
|
|
Owner common.Address
|
|
Operator common.Address
|
|
Approved bool
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterApprovalForAll is a free log retrieval operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_StickerType *StickerTypeFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*StickerTypeApprovalForAllIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerType.contract.FilterLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerTypeApprovalForAllIterator{contract: _StickerType.contract, event: "ApprovalForAll", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchApprovalForAll is a free log subscription operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_StickerType *StickerTypeFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *StickerTypeApprovalForAll, owner []common.Address, operator []common.Address) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerType.contract.WatchLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
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(StickerTypeApprovalForAll)
|
|
if err := _StickerType.contract.UnpackLog(event, "ApprovalForAll", 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
|
|
}
|
|
|
|
// ParseApprovalForAll is a log parse operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_StickerType *StickerTypeFilterer) ParseApprovalForAll(log types.Log) (*StickerTypeApprovalForAll, error) {
|
|
event := new(StickerTypeApprovalForAll)
|
|
if err := _StickerType.contract.UnpackLog(event, "ApprovalForAll", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerTypeCategorizedIterator is returned from FilterCategorized and is used to iterate over the raw logs and unpacked data for Categorized events raised by the StickerType contract.
|
|
type StickerTypeCategorizedIterator struct {
|
|
Event *StickerTypeCategorized // 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 *StickerTypeCategorizedIterator) 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(StickerTypeCategorized)
|
|
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(StickerTypeCategorized)
|
|
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 *StickerTypeCategorizedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerTypeCategorizedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerTypeCategorized represents a Categorized event raised by the StickerType contract.
|
|
type StickerTypeCategorized struct {
|
|
Category [4]byte
|
|
PackId *big.Int
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterCategorized is a free log retrieval operation binding the contract event 0x74186c4c4ee368ea5564982241efb7357014b52d6e195d026bc4fdfaa112691b.
|
|
//
|
|
// Solidity: event Categorized(bytes4 indexed category, uint256 indexed packId)
|
|
func (_StickerType *StickerTypeFilterer) FilterCategorized(opts *bind.FilterOpts, category [][4]byte, packId []*big.Int) (*StickerTypeCategorizedIterator, error) {
|
|
|
|
var categoryRule []interface{}
|
|
for _, categoryItem := range category {
|
|
categoryRule = append(categoryRule, categoryItem)
|
|
}
|
|
var packIdRule []interface{}
|
|
for _, packIdItem := range packId {
|
|
packIdRule = append(packIdRule, packIdItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerType.contract.FilterLogs(opts, "Categorized", categoryRule, packIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerTypeCategorizedIterator{contract: _StickerType.contract, event: "Categorized", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchCategorized is a free log subscription operation binding the contract event 0x74186c4c4ee368ea5564982241efb7357014b52d6e195d026bc4fdfaa112691b.
|
|
//
|
|
// Solidity: event Categorized(bytes4 indexed category, uint256 indexed packId)
|
|
func (_StickerType *StickerTypeFilterer) WatchCategorized(opts *bind.WatchOpts, sink chan<- *StickerTypeCategorized, category [][4]byte, packId []*big.Int) (event.Subscription, error) {
|
|
|
|
var categoryRule []interface{}
|
|
for _, categoryItem := range category {
|
|
categoryRule = append(categoryRule, categoryItem)
|
|
}
|
|
var packIdRule []interface{}
|
|
for _, packIdItem := range packId {
|
|
packIdRule = append(packIdRule, packIdItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerType.contract.WatchLogs(opts, "Categorized", categoryRule, packIdRule)
|
|
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(StickerTypeCategorized)
|
|
if err := _StickerType.contract.UnpackLog(event, "Categorized", 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
|
|
}
|
|
|
|
// ParseCategorized is a log parse operation binding the contract event 0x74186c4c4ee368ea5564982241efb7357014b52d6e195d026bc4fdfaa112691b.
|
|
//
|
|
// Solidity: event Categorized(bytes4 indexed category, uint256 indexed packId)
|
|
func (_StickerType *StickerTypeFilterer) ParseCategorized(log types.Log) (*StickerTypeCategorized, error) {
|
|
event := new(StickerTypeCategorized)
|
|
if err := _StickerType.contract.UnpackLog(event, "Categorized", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerTypeClaimedTokensIterator is returned from FilterClaimedTokens and is used to iterate over the raw logs and unpacked data for ClaimedTokens events raised by the StickerType contract.
|
|
type StickerTypeClaimedTokensIterator struct {
|
|
Event *StickerTypeClaimedTokens // 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 *StickerTypeClaimedTokensIterator) 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(StickerTypeClaimedTokens)
|
|
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(StickerTypeClaimedTokens)
|
|
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 *StickerTypeClaimedTokensIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerTypeClaimedTokensIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerTypeClaimedTokens represents a ClaimedTokens event raised by the StickerType contract.
|
|
type StickerTypeClaimedTokens struct {
|
|
Token common.Address
|
|
Controller common.Address
|
|
Amount *big.Int
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterClaimedTokens is a free log retrieval operation binding the contract event 0xf931edb47c50b4b4104c187b5814a9aef5f709e17e2ecf9617e860cacade929c.
|
|
//
|
|
// Solidity: event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount)
|
|
func (_StickerType *StickerTypeFilterer) FilterClaimedTokens(opts *bind.FilterOpts, _token []common.Address, _controller []common.Address) (*StickerTypeClaimedTokensIterator, error) {
|
|
|
|
var _tokenRule []interface{}
|
|
for _, _tokenItem := range _token {
|
|
_tokenRule = append(_tokenRule, _tokenItem)
|
|
}
|
|
var _controllerRule []interface{}
|
|
for _, _controllerItem := range _controller {
|
|
_controllerRule = append(_controllerRule, _controllerItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerType.contract.FilterLogs(opts, "ClaimedTokens", _tokenRule, _controllerRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerTypeClaimedTokensIterator{contract: _StickerType.contract, event: "ClaimedTokens", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchClaimedTokens is a free log subscription operation binding the contract event 0xf931edb47c50b4b4104c187b5814a9aef5f709e17e2ecf9617e860cacade929c.
|
|
//
|
|
// Solidity: event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount)
|
|
func (_StickerType *StickerTypeFilterer) WatchClaimedTokens(opts *bind.WatchOpts, sink chan<- *StickerTypeClaimedTokens, _token []common.Address, _controller []common.Address) (event.Subscription, error) {
|
|
|
|
var _tokenRule []interface{}
|
|
for _, _tokenItem := range _token {
|
|
_tokenRule = append(_tokenRule, _tokenItem)
|
|
}
|
|
var _controllerRule []interface{}
|
|
for _, _controllerItem := range _controller {
|
|
_controllerRule = append(_controllerRule, _controllerItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerType.contract.WatchLogs(opts, "ClaimedTokens", _tokenRule, _controllerRule)
|
|
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(StickerTypeClaimedTokens)
|
|
if err := _StickerType.contract.UnpackLog(event, "ClaimedTokens", 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
|
|
}
|
|
|
|
// ParseClaimedTokens is a log parse operation binding the contract event 0xf931edb47c50b4b4104c187b5814a9aef5f709e17e2ecf9617e860cacade929c.
|
|
//
|
|
// Solidity: event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount)
|
|
func (_StickerType *StickerTypeFilterer) ParseClaimedTokens(log types.Log) (*StickerTypeClaimedTokens, error) {
|
|
event := new(StickerTypeClaimedTokens)
|
|
if err := _StickerType.contract.UnpackLog(event, "ClaimedTokens", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerTypeContenthashChangedIterator is returned from FilterContenthashChanged and is used to iterate over the raw logs and unpacked data for ContenthashChanged events raised by the StickerType contract.
|
|
type StickerTypeContenthashChangedIterator struct {
|
|
Event *StickerTypeContenthashChanged // 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 *StickerTypeContenthashChangedIterator) 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(StickerTypeContenthashChanged)
|
|
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(StickerTypeContenthashChanged)
|
|
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 *StickerTypeContenthashChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerTypeContenthashChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerTypeContenthashChanged represents a ContenthashChanged event raised by the StickerType contract.
|
|
type StickerTypeContenthashChanged struct {
|
|
Packid *big.Int
|
|
Contenthash []byte
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterContenthashChanged is a free log retrieval operation binding the contract event 0x6fd3fdff55b0feb6f24c338494b36929368cd564825688c741d54b8d7fa7beb9.
|
|
//
|
|
// Solidity: event ContenthashChanged(uint256 indexed packid, bytes contenthash)
|
|
func (_StickerType *StickerTypeFilterer) FilterContenthashChanged(opts *bind.FilterOpts, packid []*big.Int) (*StickerTypeContenthashChangedIterator, error) {
|
|
|
|
var packidRule []interface{}
|
|
for _, packidItem := range packid {
|
|
packidRule = append(packidRule, packidItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerType.contract.FilterLogs(opts, "ContenthashChanged", packidRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerTypeContenthashChangedIterator{contract: _StickerType.contract, event: "ContenthashChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchContenthashChanged is a free log subscription operation binding the contract event 0x6fd3fdff55b0feb6f24c338494b36929368cd564825688c741d54b8d7fa7beb9.
|
|
//
|
|
// Solidity: event ContenthashChanged(uint256 indexed packid, bytes contenthash)
|
|
func (_StickerType *StickerTypeFilterer) WatchContenthashChanged(opts *bind.WatchOpts, sink chan<- *StickerTypeContenthashChanged, packid []*big.Int) (event.Subscription, error) {
|
|
|
|
var packidRule []interface{}
|
|
for _, packidItem := range packid {
|
|
packidRule = append(packidRule, packidItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerType.contract.WatchLogs(opts, "ContenthashChanged", packidRule)
|
|
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(StickerTypeContenthashChanged)
|
|
if err := _StickerType.contract.UnpackLog(event, "ContenthashChanged", 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
|
|
}
|
|
|
|
// ParseContenthashChanged is a log parse operation binding the contract event 0x6fd3fdff55b0feb6f24c338494b36929368cd564825688c741d54b8d7fa7beb9.
|
|
//
|
|
// Solidity: event ContenthashChanged(uint256 indexed packid, bytes contenthash)
|
|
func (_StickerType *StickerTypeFilterer) ParseContenthashChanged(log types.Log) (*StickerTypeContenthashChanged, error) {
|
|
event := new(StickerTypeContenthashChanged)
|
|
if err := _StickerType.contract.UnpackLog(event, "ContenthashChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerTypeMintabilityChangedIterator is returned from FilterMintabilityChanged and is used to iterate over the raw logs and unpacked data for MintabilityChanged events raised by the StickerType contract.
|
|
type StickerTypeMintabilityChangedIterator struct {
|
|
Event *StickerTypeMintabilityChanged // 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 *StickerTypeMintabilityChangedIterator) 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(StickerTypeMintabilityChanged)
|
|
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(StickerTypeMintabilityChanged)
|
|
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 *StickerTypeMintabilityChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerTypeMintabilityChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerTypeMintabilityChanged represents a MintabilityChanged event raised by the StickerType contract.
|
|
type StickerTypeMintabilityChanged struct {
|
|
PackId *big.Int
|
|
Mintable bool
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterMintabilityChanged is a free log retrieval operation binding the contract event 0x7a5b9103727f29409c14d2581e9710a1648b1354e667e1c803d4bda045159660.
|
|
//
|
|
// Solidity: event MintabilityChanged(uint256 indexed packId, bool mintable)
|
|
func (_StickerType *StickerTypeFilterer) FilterMintabilityChanged(opts *bind.FilterOpts, packId []*big.Int) (*StickerTypeMintabilityChangedIterator, error) {
|
|
|
|
var packIdRule []interface{}
|
|
for _, packIdItem := range packId {
|
|
packIdRule = append(packIdRule, packIdItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerType.contract.FilterLogs(opts, "MintabilityChanged", packIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerTypeMintabilityChangedIterator{contract: _StickerType.contract, event: "MintabilityChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchMintabilityChanged is a free log subscription operation binding the contract event 0x7a5b9103727f29409c14d2581e9710a1648b1354e667e1c803d4bda045159660.
|
|
//
|
|
// Solidity: event MintabilityChanged(uint256 indexed packId, bool mintable)
|
|
func (_StickerType *StickerTypeFilterer) WatchMintabilityChanged(opts *bind.WatchOpts, sink chan<- *StickerTypeMintabilityChanged, packId []*big.Int) (event.Subscription, error) {
|
|
|
|
var packIdRule []interface{}
|
|
for _, packIdItem := range packId {
|
|
packIdRule = append(packIdRule, packIdItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerType.contract.WatchLogs(opts, "MintabilityChanged", packIdRule)
|
|
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(StickerTypeMintabilityChanged)
|
|
if err := _StickerType.contract.UnpackLog(event, "MintabilityChanged", 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
|
|
}
|
|
|
|
// ParseMintabilityChanged is a log parse operation binding the contract event 0x7a5b9103727f29409c14d2581e9710a1648b1354e667e1c803d4bda045159660.
|
|
//
|
|
// Solidity: event MintabilityChanged(uint256 indexed packId, bool mintable)
|
|
func (_StickerType *StickerTypeFilterer) ParseMintabilityChanged(log types.Log) (*StickerTypeMintabilityChanged, error) {
|
|
event := new(StickerTypeMintabilityChanged)
|
|
if err := _StickerType.contract.UnpackLog(event, "MintabilityChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerTypeNewControllerIterator is returned from FilterNewController and is used to iterate over the raw logs and unpacked data for NewController events raised by the StickerType contract.
|
|
type StickerTypeNewControllerIterator struct {
|
|
Event *StickerTypeNewController // 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 *StickerTypeNewControllerIterator) 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(StickerTypeNewController)
|
|
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(StickerTypeNewController)
|
|
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 *StickerTypeNewControllerIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerTypeNewControllerIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerTypeNewController represents a NewController event raised by the StickerType contract.
|
|
type StickerTypeNewController struct {
|
|
Controller common.Address
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterNewController is a free log retrieval operation binding the contract event 0xe253457d9ad994ca9682fc3bbc38c890dca73a2d5ecee3809e548bac8b00d7c6.
|
|
//
|
|
// Solidity: event NewController(address controller)
|
|
func (_StickerType *StickerTypeFilterer) FilterNewController(opts *bind.FilterOpts) (*StickerTypeNewControllerIterator, error) {
|
|
|
|
logs, sub, err := _StickerType.contract.FilterLogs(opts, "NewController")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerTypeNewControllerIterator{contract: _StickerType.contract, event: "NewController", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchNewController is a free log subscription operation binding the contract event 0xe253457d9ad994ca9682fc3bbc38c890dca73a2d5ecee3809e548bac8b00d7c6.
|
|
//
|
|
// Solidity: event NewController(address controller)
|
|
func (_StickerType *StickerTypeFilterer) WatchNewController(opts *bind.WatchOpts, sink chan<- *StickerTypeNewController) (event.Subscription, error) {
|
|
|
|
logs, sub, err := _StickerType.contract.WatchLogs(opts, "NewController")
|
|
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(StickerTypeNewController)
|
|
if err := _StickerType.contract.UnpackLog(event, "NewController", 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
|
|
}
|
|
|
|
// ParseNewController is a log parse operation binding the contract event 0xe253457d9ad994ca9682fc3bbc38c890dca73a2d5ecee3809e548bac8b00d7c6.
|
|
//
|
|
// Solidity: event NewController(address controller)
|
|
func (_StickerType *StickerTypeFilterer) ParseNewController(log types.Log) (*StickerTypeNewController, error) {
|
|
event := new(StickerTypeNewController)
|
|
if err := _StickerType.contract.UnpackLog(event, "NewController", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerTypePriceChangedIterator is returned from FilterPriceChanged and is used to iterate over the raw logs and unpacked data for PriceChanged events raised by the StickerType contract.
|
|
type StickerTypePriceChangedIterator struct {
|
|
Event *StickerTypePriceChanged // 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 *StickerTypePriceChangedIterator) 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(StickerTypePriceChanged)
|
|
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(StickerTypePriceChanged)
|
|
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 *StickerTypePriceChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerTypePriceChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerTypePriceChanged represents a PriceChanged event raised by the StickerType contract.
|
|
type StickerTypePriceChanged struct {
|
|
PackId *big.Int
|
|
DataPrice *big.Int
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterPriceChanged is a free log retrieval operation binding the contract event 0x8aa4fa52648a6d15edce8a179c792c86f3719d0cc3c572cf90f91948f0f2cb68.
|
|
//
|
|
// Solidity: event PriceChanged(uint256 indexed packId, uint256 dataPrice)
|
|
func (_StickerType *StickerTypeFilterer) FilterPriceChanged(opts *bind.FilterOpts, packId []*big.Int) (*StickerTypePriceChangedIterator, error) {
|
|
|
|
var packIdRule []interface{}
|
|
for _, packIdItem := range packId {
|
|
packIdRule = append(packIdRule, packIdItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerType.contract.FilterLogs(opts, "PriceChanged", packIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerTypePriceChangedIterator{contract: _StickerType.contract, event: "PriceChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchPriceChanged is a free log subscription operation binding the contract event 0x8aa4fa52648a6d15edce8a179c792c86f3719d0cc3c572cf90f91948f0f2cb68.
|
|
//
|
|
// Solidity: event PriceChanged(uint256 indexed packId, uint256 dataPrice)
|
|
func (_StickerType *StickerTypeFilterer) WatchPriceChanged(opts *bind.WatchOpts, sink chan<- *StickerTypePriceChanged, packId []*big.Int) (event.Subscription, error) {
|
|
|
|
var packIdRule []interface{}
|
|
for _, packIdItem := range packId {
|
|
packIdRule = append(packIdRule, packIdItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerType.contract.WatchLogs(opts, "PriceChanged", packIdRule)
|
|
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(StickerTypePriceChanged)
|
|
if err := _StickerType.contract.UnpackLog(event, "PriceChanged", 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
|
|
}
|
|
|
|
// ParsePriceChanged is a log parse operation binding the contract event 0x8aa4fa52648a6d15edce8a179c792c86f3719d0cc3c572cf90f91948f0f2cb68.
|
|
//
|
|
// Solidity: event PriceChanged(uint256 indexed packId, uint256 dataPrice)
|
|
func (_StickerType *StickerTypeFilterer) ParsePriceChanged(log types.Log) (*StickerTypePriceChanged, error) {
|
|
event := new(StickerTypePriceChanged)
|
|
if err := _StickerType.contract.UnpackLog(event, "PriceChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerTypeRegisterIterator is returned from FilterRegister and is used to iterate over the raw logs and unpacked data for Register events raised by the StickerType contract.
|
|
type StickerTypeRegisterIterator struct {
|
|
Event *StickerTypeRegister // 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 *StickerTypeRegisterIterator) 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(StickerTypeRegister)
|
|
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(StickerTypeRegister)
|
|
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 *StickerTypeRegisterIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerTypeRegisterIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerTypeRegister represents a Register event raised by the StickerType contract.
|
|
type StickerTypeRegister struct {
|
|
PackId *big.Int
|
|
DataPrice *big.Int
|
|
Contenthash []byte
|
|
Mintable bool
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterRegister is a free log retrieval operation binding the contract event 0x8304dd8a0ecd1927e64564792f1147f0aca02ba211e48c2981bf7244a9877975.
|
|
//
|
|
// Solidity: event Register(uint256 indexed packId, uint256 dataPrice, bytes contenthash, bool mintable)
|
|
func (_StickerType *StickerTypeFilterer) FilterRegister(opts *bind.FilterOpts, packId []*big.Int) (*StickerTypeRegisterIterator, error) {
|
|
|
|
var packIdRule []interface{}
|
|
for _, packIdItem := range packId {
|
|
packIdRule = append(packIdRule, packIdItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerType.contract.FilterLogs(opts, "Register", packIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerTypeRegisterIterator{contract: _StickerType.contract, event: "Register", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchRegister is a free log subscription operation binding the contract event 0x8304dd8a0ecd1927e64564792f1147f0aca02ba211e48c2981bf7244a9877975.
|
|
//
|
|
// Solidity: event Register(uint256 indexed packId, uint256 dataPrice, bytes contenthash, bool mintable)
|
|
func (_StickerType *StickerTypeFilterer) WatchRegister(opts *bind.WatchOpts, sink chan<- *StickerTypeRegister, packId []*big.Int) (event.Subscription, error) {
|
|
|
|
var packIdRule []interface{}
|
|
for _, packIdItem := range packId {
|
|
packIdRule = append(packIdRule, packIdItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerType.contract.WatchLogs(opts, "Register", packIdRule)
|
|
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(StickerTypeRegister)
|
|
if err := _StickerType.contract.UnpackLog(event, "Register", 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
|
|
}
|
|
|
|
// ParseRegister is a log parse operation binding the contract event 0x8304dd8a0ecd1927e64564792f1147f0aca02ba211e48c2981bf7244a9877975.
|
|
//
|
|
// Solidity: event Register(uint256 indexed packId, uint256 dataPrice, bytes contenthash, bool mintable)
|
|
func (_StickerType *StickerTypeFilterer) ParseRegister(log types.Log) (*StickerTypeRegister, error) {
|
|
event := new(StickerTypeRegister)
|
|
if err := _StickerType.contract.UnpackLog(event, "Register", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerTypeTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the StickerType contract.
|
|
type StickerTypeTransferIterator struct {
|
|
Event *StickerTypeTransfer // 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 *StickerTypeTransferIterator) 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(StickerTypeTransfer)
|
|
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(StickerTypeTransfer)
|
|
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 *StickerTypeTransferIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerTypeTransferIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerTypeTransfer represents a Transfer event raised by the StickerType contract.
|
|
type StickerTypeTransfer struct {
|
|
From common.Address
|
|
To common.Address
|
|
TokenId *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 indexed tokenId)
|
|
func (_StickerType *StickerTypeFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address, tokenId []*big.Int) (*StickerTypeTransferIterator, error) {
|
|
|
|
var fromRule []interface{}
|
|
for _, fromItem := range from {
|
|
fromRule = append(fromRule, fromItem)
|
|
}
|
|
var toRule []interface{}
|
|
for _, toItem := range to {
|
|
toRule = append(toRule, toItem)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerType.contract.FilterLogs(opts, "Transfer", fromRule, toRule, tokenIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerTypeTransferIterator{contract: _StickerType.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 indexed tokenId)
|
|
func (_StickerType *StickerTypeFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *StickerTypeTransfer, from []common.Address, to []common.Address, tokenId []*big.Int) (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)
|
|
}
|
|
var tokenIdRule []interface{}
|
|
for _, tokenIdItem := range tokenId {
|
|
tokenIdRule = append(tokenIdRule, tokenIdItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerType.contract.WatchLogs(opts, "Transfer", fromRule, toRule, tokenIdRule)
|
|
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(StickerTypeTransfer)
|
|
if err := _StickerType.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 indexed tokenId)
|
|
func (_StickerType *StickerTypeFilterer) ParseTransfer(log types.Log) (*StickerTypeTransfer, error) {
|
|
event := new(StickerTypeTransfer)
|
|
if err := _StickerType.contract.UnpackLog(event, "Transfer", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerTypeUncategorizedIterator is returned from FilterUncategorized and is used to iterate over the raw logs and unpacked data for Uncategorized events raised by the StickerType contract.
|
|
type StickerTypeUncategorizedIterator struct {
|
|
Event *StickerTypeUncategorized // 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 *StickerTypeUncategorizedIterator) 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(StickerTypeUncategorized)
|
|
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(StickerTypeUncategorized)
|
|
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 *StickerTypeUncategorizedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerTypeUncategorizedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerTypeUncategorized represents a Uncategorized event raised by the StickerType contract.
|
|
type StickerTypeUncategorized struct {
|
|
Category [4]byte
|
|
PackId *big.Int
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterUncategorized is a free log retrieval operation binding the contract event 0x9574a9d09dc883e69228a0eea15ed4da6e520b13cc84cca994c1787c234d78fe.
|
|
//
|
|
// Solidity: event Uncategorized(bytes4 indexed category, uint256 indexed packId)
|
|
func (_StickerType *StickerTypeFilterer) FilterUncategorized(opts *bind.FilterOpts, category [][4]byte, packId []*big.Int) (*StickerTypeUncategorizedIterator, error) {
|
|
|
|
var categoryRule []interface{}
|
|
for _, categoryItem := range category {
|
|
categoryRule = append(categoryRule, categoryItem)
|
|
}
|
|
var packIdRule []interface{}
|
|
for _, packIdItem := range packId {
|
|
packIdRule = append(packIdRule, packIdItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerType.contract.FilterLogs(opts, "Uncategorized", categoryRule, packIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerTypeUncategorizedIterator{contract: _StickerType.contract, event: "Uncategorized", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchUncategorized is a free log subscription operation binding the contract event 0x9574a9d09dc883e69228a0eea15ed4da6e520b13cc84cca994c1787c234d78fe.
|
|
//
|
|
// Solidity: event Uncategorized(bytes4 indexed category, uint256 indexed packId)
|
|
func (_StickerType *StickerTypeFilterer) WatchUncategorized(opts *bind.WatchOpts, sink chan<- *StickerTypeUncategorized, category [][4]byte, packId []*big.Int) (event.Subscription, error) {
|
|
|
|
var categoryRule []interface{}
|
|
for _, categoryItem := range category {
|
|
categoryRule = append(categoryRule, categoryItem)
|
|
}
|
|
var packIdRule []interface{}
|
|
for _, packIdItem := range packId {
|
|
packIdRule = append(packIdRule, packIdItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerType.contract.WatchLogs(opts, "Uncategorized", categoryRule, packIdRule)
|
|
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(StickerTypeUncategorized)
|
|
if err := _StickerType.contract.UnpackLog(event, "Uncategorized", 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
|
|
}
|
|
|
|
// ParseUncategorized is a log parse operation binding the contract event 0x9574a9d09dc883e69228a0eea15ed4da6e520b13cc84cca994c1787c234d78fe.
|
|
//
|
|
// Solidity: event Uncategorized(bytes4 indexed category, uint256 indexed packId)
|
|
func (_StickerType *StickerTypeFilterer) ParseUncategorized(log types.Log) (*StickerTypeUncategorized, error) {
|
|
event := new(StickerTypeUncategorized)
|
|
if err := _StickerType.contract.UnpackLog(event, "Uncategorized", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// StickerTypeUnregisterIterator is returned from FilterUnregister and is used to iterate over the raw logs and unpacked data for Unregister events raised by the StickerType contract.
|
|
type StickerTypeUnregisterIterator struct {
|
|
Event *StickerTypeUnregister // 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 *StickerTypeUnregisterIterator) 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(StickerTypeUnregister)
|
|
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(StickerTypeUnregister)
|
|
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 *StickerTypeUnregisterIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *StickerTypeUnregisterIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// StickerTypeUnregister represents a Unregister event raised by the StickerType contract.
|
|
type StickerTypeUnregister struct {
|
|
PackId *big.Int
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterUnregister is a free log retrieval operation binding the contract event 0x98f986773731debbbf041b73d7edaec62da3ff42b2116c45cd0001fb40ed9086.
|
|
//
|
|
// Solidity: event Unregister(uint256 indexed packId)
|
|
func (_StickerType *StickerTypeFilterer) FilterUnregister(opts *bind.FilterOpts, packId []*big.Int) (*StickerTypeUnregisterIterator, error) {
|
|
|
|
var packIdRule []interface{}
|
|
for _, packIdItem := range packId {
|
|
packIdRule = append(packIdRule, packIdItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerType.contract.FilterLogs(opts, "Unregister", packIdRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &StickerTypeUnregisterIterator{contract: _StickerType.contract, event: "Unregister", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchUnregister is a free log subscription operation binding the contract event 0x98f986773731debbbf041b73d7edaec62da3ff42b2116c45cd0001fb40ed9086.
|
|
//
|
|
// Solidity: event Unregister(uint256 indexed packId)
|
|
func (_StickerType *StickerTypeFilterer) WatchUnregister(opts *bind.WatchOpts, sink chan<- *StickerTypeUnregister, packId []*big.Int) (event.Subscription, error) {
|
|
|
|
var packIdRule []interface{}
|
|
for _, packIdItem := range packId {
|
|
packIdRule = append(packIdRule, packIdItem)
|
|
}
|
|
|
|
logs, sub, err := _StickerType.contract.WatchLogs(opts, "Unregister", packIdRule)
|
|
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(StickerTypeUnregister)
|
|
if err := _StickerType.contract.UnpackLog(event, "Unregister", 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
|
|
}
|
|
|
|
// ParseUnregister is a log parse operation binding the contract event 0x98f986773731debbbf041b73d7edaec62da3ff42b2116c45cd0001fb40ed9086.
|
|
//
|
|
// Solidity: event Unregister(uint256 indexed packId)
|
|
func (_StickerType *StickerTypeFilterer) ParseUnregister(log types.Log) (*StickerTypeUnregister, error) {
|
|
event := new(StickerTypeUnregister)
|
|
if err := _StickerType.contract.UnpackLog(event, "Unregister", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// TokenClaimerABI is the input ABI used to generate the binding from.
|
|
const TokenClaimerABI = "[{\"constant\":false,\"inputs\":[{\"name\":\"_token\",\"type\":\"address\"}],\"name\":\"claimTokens\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"_token\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"_controller\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"ClaimedTokens\",\"type\":\"event\"}]"
|
|
|
|
// TokenClaimerFuncSigs maps the 4-byte function signature to its string representation.
|
|
var TokenClaimerFuncSigs = map[string]string{
|
|
"df8de3e7": "claimTokens(address)",
|
|
}
|
|
|
|
// TokenClaimer is an auto generated Go binding around an Ethereum contract.
|
|
type TokenClaimer struct {
|
|
TokenClaimerCaller // Read-only binding to the contract
|
|
TokenClaimerTransactor // Write-only binding to the contract
|
|
TokenClaimerFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// TokenClaimerCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type TokenClaimerCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// TokenClaimerTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type TokenClaimerTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// TokenClaimerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type TokenClaimerFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// TokenClaimerSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type TokenClaimerSession struct {
|
|
Contract *TokenClaimer // 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
|
|
}
|
|
|
|
// TokenClaimerCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type TokenClaimerCallerSession struct {
|
|
Contract *TokenClaimerCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// TokenClaimerTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type TokenClaimerTransactorSession struct {
|
|
Contract *TokenClaimerTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// TokenClaimerRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type TokenClaimerRaw struct {
|
|
Contract *TokenClaimer // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// TokenClaimerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type TokenClaimerCallerRaw struct {
|
|
Contract *TokenClaimerCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// TokenClaimerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type TokenClaimerTransactorRaw struct {
|
|
Contract *TokenClaimerTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewTokenClaimer creates a new instance of TokenClaimer, bound to a specific deployed contract.
|
|
func NewTokenClaimer(address common.Address, backend bind.ContractBackend) (*TokenClaimer, error) {
|
|
contract, err := bindTokenClaimer(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &TokenClaimer{TokenClaimerCaller: TokenClaimerCaller{contract: contract}, TokenClaimerTransactor: TokenClaimerTransactor{contract: contract}, TokenClaimerFilterer: TokenClaimerFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewTokenClaimerCaller creates a new read-only instance of TokenClaimer, bound to a specific deployed contract.
|
|
func NewTokenClaimerCaller(address common.Address, caller bind.ContractCaller) (*TokenClaimerCaller, error) {
|
|
contract, err := bindTokenClaimer(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &TokenClaimerCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewTokenClaimerTransactor creates a new write-only instance of TokenClaimer, bound to a specific deployed contract.
|
|
func NewTokenClaimerTransactor(address common.Address, transactor bind.ContractTransactor) (*TokenClaimerTransactor, error) {
|
|
contract, err := bindTokenClaimer(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &TokenClaimerTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewTokenClaimerFilterer creates a new log filterer instance of TokenClaimer, bound to a specific deployed contract.
|
|
func NewTokenClaimerFilterer(address common.Address, filterer bind.ContractFilterer) (*TokenClaimerFilterer, error) {
|
|
contract, err := bindTokenClaimer(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &TokenClaimerFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindTokenClaimer binds a generic wrapper to an already deployed contract.
|
|
func bindTokenClaimer(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(TokenClaimerABI))
|
|
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 (_TokenClaimer *TokenClaimerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _TokenClaimer.Contract.TokenClaimerCaller.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 (_TokenClaimer *TokenClaimerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _TokenClaimer.Contract.TokenClaimerTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_TokenClaimer *TokenClaimerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _TokenClaimer.Contract.TokenClaimerTransactor.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 (_TokenClaimer *TokenClaimerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _TokenClaimer.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 (_TokenClaimer *TokenClaimerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _TokenClaimer.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_TokenClaimer *TokenClaimerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _TokenClaimer.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// ClaimTokens is a paid mutator transaction binding the contract method 0xdf8de3e7.
|
|
//
|
|
// Solidity: function claimTokens(address _token) returns()
|
|
func (_TokenClaimer *TokenClaimerTransactor) ClaimTokens(opts *bind.TransactOpts, _token common.Address) (*types.Transaction, error) {
|
|
return _TokenClaimer.contract.Transact(opts, "claimTokens", _token)
|
|
}
|
|
|
|
// ClaimTokens is a paid mutator transaction binding the contract method 0xdf8de3e7.
|
|
//
|
|
// Solidity: function claimTokens(address _token) returns()
|
|
func (_TokenClaimer *TokenClaimerSession) ClaimTokens(_token common.Address) (*types.Transaction, error) {
|
|
return _TokenClaimer.Contract.ClaimTokens(&_TokenClaimer.TransactOpts, _token)
|
|
}
|
|
|
|
// ClaimTokens is a paid mutator transaction binding the contract method 0xdf8de3e7.
|
|
//
|
|
// Solidity: function claimTokens(address _token) returns()
|
|
func (_TokenClaimer *TokenClaimerTransactorSession) ClaimTokens(_token common.Address) (*types.Transaction, error) {
|
|
return _TokenClaimer.Contract.ClaimTokens(&_TokenClaimer.TransactOpts, _token)
|
|
}
|
|
|
|
// TokenClaimerClaimedTokensIterator is returned from FilterClaimedTokens and is used to iterate over the raw logs and unpacked data for ClaimedTokens events raised by the TokenClaimer contract.
|
|
type TokenClaimerClaimedTokensIterator struct {
|
|
Event *TokenClaimerClaimedTokens // 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 *TokenClaimerClaimedTokensIterator) 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(TokenClaimerClaimedTokens)
|
|
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(TokenClaimerClaimedTokens)
|
|
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 *TokenClaimerClaimedTokensIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *TokenClaimerClaimedTokensIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// TokenClaimerClaimedTokens represents a ClaimedTokens event raised by the TokenClaimer contract.
|
|
type TokenClaimerClaimedTokens struct {
|
|
Token common.Address
|
|
Controller common.Address
|
|
Amount *big.Int
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterClaimedTokens is a free log retrieval operation binding the contract event 0xf931edb47c50b4b4104c187b5814a9aef5f709e17e2ecf9617e860cacade929c.
|
|
//
|
|
// Solidity: event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount)
|
|
func (_TokenClaimer *TokenClaimerFilterer) FilterClaimedTokens(opts *bind.FilterOpts, _token []common.Address, _controller []common.Address) (*TokenClaimerClaimedTokensIterator, error) {
|
|
|
|
var _tokenRule []interface{}
|
|
for _, _tokenItem := range _token {
|
|
_tokenRule = append(_tokenRule, _tokenItem)
|
|
}
|
|
var _controllerRule []interface{}
|
|
for _, _controllerItem := range _controller {
|
|
_controllerRule = append(_controllerRule, _controllerItem)
|
|
}
|
|
|
|
logs, sub, err := _TokenClaimer.contract.FilterLogs(opts, "ClaimedTokens", _tokenRule, _controllerRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &TokenClaimerClaimedTokensIterator{contract: _TokenClaimer.contract, event: "ClaimedTokens", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchClaimedTokens is a free log subscription operation binding the contract event 0xf931edb47c50b4b4104c187b5814a9aef5f709e17e2ecf9617e860cacade929c.
|
|
//
|
|
// Solidity: event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount)
|
|
func (_TokenClaimer *TokenClaimerFilterer) WatchClaimedTokens(opts *bind.WatchOpts, sink chan<- *TokenClaimerClaimedTokens, _token []common.Address, _controller []common.Address) (event.Subscription, error) {
|
|
|
|
var _tokenRule []interface{}
|
|
for _, _tokenItem := range _token {
|
|
_tokenRule = append(_tokenRule, _tokenItem)
|
|
}
|
|
var _controllerRule []interface{}
|
|
for _, _controllerItem := range _controller {
|
|
_controllerRule = append(_controllerRule, _controllerItem)
|
|
}
|
|
|
|
logs, sub, err := _TokenClaimer.contract.WatchLogs(opts, "ClaimedTokens", _tokenRule, _controllerRule)
|
|
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(TokenClaimerClaimedTokens)
|
|
if err := _TokenClaimer.contract.UnpackLog(event, "ClaimedTokens", 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
|
|
}
|
|
|
|
// ParseClaimedTokens is a log parse operation binding the contract event 0xf931edb47c50b4b4104c187b5814a9aef5f709e17e2ecf9617e860cacade929c.
|
|
//
|
|
// Solidity: event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount)
|
|
func (_TokenClaimer *TokenClaimerFilterer) ParseClaimedTokens(log types.Log) (*TokenClaimerClaimedTokens, error) {
|
|
event := new(TokenClaimerClaimedTokens)
|
|
if err := _TokenClaimer.contract.UnpackLog(event, "ClaimedTokens", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|