evm/pancakeswap/contracts/nftmarket.go

// Code generated - DO NOT EDIT.
// This file is a generated binding and any manual changes will be lost.

package contracts

import (
	"errors"
	"math/big"
	"strings"

	ethereum "github.com/ethereum/go-ethereum"
	"github.com/ethereum/go-ethereum/accounts/abi"
	"github.com/ethereum/go-ethereum/accounts/abi/bind"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/event"
)

// Reference imports to suppress errors if they are not otherwise used.
var (
	_ = errors.New
	_ = big.NewInt
	_ = strings.NewReader
	_ = ethereum.NotFound
	_ = bind.Bind
	_ = common.Big1
	_ = types.BloomLookup
	_ = event.NewSubscription
)

// ERC721NFTMarketV1Ask is an auto generated low-level Go binding around an user-defined struct.
type ERC721NFTMarketV1Ask struct {
	Seller common.Address
	Price  *big.Int
}

// ERC721NFTMarketV1Collection is an auto generated low-level Go binding around an user-defined struct.
type ERC721NFTMarketV1Collection struct {
	Status           uint8
	CreatorAddress   common.Address
	WhitelistChecker common.Address
	TradingFee       *big.Int
	CreatorFee       *big.Int
}

// NftMarketMetaData contains all meta data concerning the NftMarket contract.
var NftMarketMetaData = &bind.MetaData{
	ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_adminAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_treasuryAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_WBNBAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_minimumAskPrice\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_maximumAskPrice\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collection\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"seller\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"AskCancel\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collection\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"seller\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"askPrice\",\"type\":\"uint256\"}],\"name\":\"AskNew\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collection\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"seller\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"askPrice\",\"type\":\"uint256\"}],\"name\":\"AskUpdate\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collection\",\"type\":\"address\"}],\"name\":\"CollectionClose\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collection\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"creator\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"whitelistChecker\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tradingFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"creatorFee\",\"type\":\"uint256\"}],\"name\":\"CollectionNew\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collection\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"creator\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"whitelistChecker\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tradingFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"creatorFee\",\"type\":\"uint256\"}],\"name\":\"CollectionUpdate\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"treasury\",\"type\":\"address\"}],\"name\":\"NewAdminAndTreasuryAddresses\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"minimumAskPrice\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"maximumAskPrice\",\"type\":\"uint256\"}],\"name\":\"NewMinimumAndMaximumAskPrices\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"NonFungibleTokenRecovery\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"typ
}

// NftMarketABI is the input ABI used to generate the binding from.
// Deprecated: Use NftMarketMetaData.ABI instead.
var NftMarketABI = NftMarketMetaData.ABI

// NftMarket is an auto generated Go binding around an Ethereum contract.
type NftMarket struct {
	NftMarketCaller     // Read-only binding to the contract
	NftMarketTransactor // Write-only binding to the contract
	NftMarketFilterer   // Log filterer for contract events
}

// NftMarketCaller is an auto generated read-only Go binding around an Ethereum contract.
type NftMarketCaller struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// NftMarketTransactor is an auto generated write-only Go binding around an Ethereum contract.
type NftMarketTransactor struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// NftMarketFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
type NftMarketFilterer struct {
	contract *bind.BoundContract // Generic contract wrapper for the low level calls
}

// NftMarketSession is an auto generated Go binding around an Ethereum contract,
// with pre-set call and transact options.
type NftMarketSession struct {
	Contract     *NftMarket        // 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
}

// NftMarketCallerSession is an auto generated read-only Go binding around an Ethereum contract,
// with pre-set call options.
type NftMarketCallerSession struct {
	Contract *NftMarketCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts    // Call options to use throughout this session
}

// NftMarketTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
// with pre-set transact options.
type NftMarketTransactorSession struct {
	Contract     *NftMarketTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts    // Transaction auth options to use throughout this session
}

// NftMarketRaw is an auto generated low-level Go binding around an Ethereum contract.
type NftMarketRaw struct {
	Contract *NftMarket // Generic contract binding to access the raw methods on
}

// NftMarketCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
type NftMarketCallerRaw struct {
	Contract *NftMarketCaller // Generic read-only contract binding to access the raw methods on
}

// NftMarketTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
type NftMarketTransactorRaw struct {
	Contract *NftMarketTransactor // Generic write-only contract binding to access the raw methods on
}

// NewNftMarket creates a new instance of NftMarket, bound to a specific deployed contract.
func NewNftMarket(address common.Address, backend bind.ContractBackend) (*NftMarket, error) {
	contract, err := bindNftMarket(address, backend, backend, backend)
	if err != nil {
		return nil, err
	}
	return &NftMarket{NftMarketCaller: NftMarketCaller{contract: contract}, NftMarketTransactor: NftMarketTransactor{contract: contract}, NftMarketFilterer: NftMarketFilterer{contract: contract}}, nil
}

// NewNftMarketCaller creates a new read-only instance of NftMarket, bound to a specific deployed contract.
func NewNftMarketCaller(address common.Address, caller bind.ContractCaller) (*NftMarketCaller, error) {
	contract, err := bindNftMarket(address, caller, nil, nil)
	if err != nil {
		return nil, err
	}
	return &NftMarketCaller{contract: contract}, nil
}

// NewNftMarketTransactor creates a new write-only instance of NftMarket, bound to a specific deployed contract.
func NewNftMarketTransactor(address common.Address, transactor bind.ContractTransactor) (*NftMarketTransactor, error) {
	contract, err := bindNftMarket(address, nil, transactor, nil)
	if err != nil {
		return nil, err
	}
	return &NftMarketTransactor{contract: contract}, nil
}

// NewNftMarketFilterer creates a new log filterer instance of NftMarket, bound to a specific deployed contract.
func NewNftMarketFilterer(address common.Address, filterer bind.ContractFilterer) (*NftMarketFilterer, error) {
	contract, err := bindNftMarket(address, nil, nil, filterer)
	if err != nil {
		return nil, err
	}
	return &NftMarketFilterer{contract: contract}, nil
}

// bindNftMarket binds a generic wrapper to an already deployed contract.
func bindNftMarket(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
	parsed, err := abi.JSON(strings.NewReader(NftMarketABI))
	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 (_NftMarket *NftMarketRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _NftMarket.Contract.NftMarketCaller.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 (_NftMarket *NftMarketRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _NftMarket.Contract.NftMarketTransactor.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_NftMarket *NftMarketRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _NftMarket.Contract.NftMarketTransactor.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 (_NftMarket *NftMarketCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
	return _NftMarket.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 (_NftMarket *NftMarketTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _NftMarket.Contract.contract.Transfer(opts)
}

// Transact invokes the (paid) contract method with params as input values.
func (_NftMarket *NftMarketTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
	return _NftMarket.Contract.contract.Transact(opts, method, params...)
}

// TOTALMAXFEE is a free data retrieval call binding the contract method 0x209cbe7e.
//
// Solidity: function TOTAL_MAX_FEE() view returns(uint256)
func (_NftMarket *NftMarketCaller) TOTALMAXFEE(opts *bind.CallOpts) (*big.Int, error) {
	var out []interface{}
	err := _NftMarket.contract.Call(opts, &out, "TOTAL_MAX_FEE")

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// TOTALMAXFEE is a free data retrieval call binding the contract method 0x209cbe7e.
//
// Solidity: function TOTAL_MAX_FEE() view returns(uint256)
func (_NftMarket *NftMarketSession) TOTALMAXFEE() (*big.Int, error) {
	return _NftMarket.Contract.TOTALMAXFEE(&_NftMarket.CallOpts)
}

// TOTALMAXFEE is a free data retrieval call binding the contract method 0x209cbe7e.
//
// Solidity: function TOTAL_MAX_FEE() view returns(uint256)
func (_NftMarket *NftMarketCallerSession) TOTALMAXFEE() (*big.Int, error) {
	return _NftMarket.Contract.TOTALMAXFEE(&_NftMarket.CallOpts)
}

// WBNB is a free data retrieval call binding the contract method 0x8dd95002.
//
// Solidity: function WBNB() view returns(address)
func (_NftMarket *NftMarketCaller) WBNB(opts *bind.CallOpts) (common.Address, error) {
	var out []interface{}
	err := _NftMarket.contract.Call(opts, &out, "WBNB")

	if err != nil {
		return *new(common.Address), err
	}

	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)

	return out0, err

}

// WBNB is a free data retrieval call binding the contract method 0x8dd95002.
//
// Solidity: function WBNB() view returns(address)
func (_NftMarket *NftMarketSession) WBNB() (common.Address, error) {
	return _NftMarket.Contract.WBNB(&_NftMarket.CallOpts)
}

// WBNB is a free data retrieval call binding the contract method 0x8dd95002.
//
// Solidity: function WBNB() view returns(address)
func (_NftMarket *NftMarketCallerSession) WBNB() (common.Address, error) {
	return _NftMarket.Contract.WBNB(&_NftMarket.CallOpts)
}

// AdminAddress is a free data retrieval call binding the contract method 0xfc6f9468.
//
// Solidity: function adminAddress() view returns(address)
func (_NftMarket *NftMarketCaller) AdminAddress(opts *bind.CallOpts) (common.Address, error) {
	var out []interface{}
	err := _NftMarket.contract.Call(opts, &out, "adminAddress")

	if err != nil {
		return *new(common.Address), err
	}

	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)

	return out0, err

}

// AdminAddress is a free data retrieval call binding the contract method 0xfc6f9468.
//
// Solidity: function adminAddress() view returns(address)
func (_NftMarket *NftMarketSession) AdminAddress() (common.Address, error) {
	return _NftMarket.Contract.AdminAddress(&_NftMarket.CallOpts)
}

// AdminAddress is a free data retrieval call binding the contract method 0xfc6f9468.
//
// Solidity: function adminAddress() view returns(address)
func (_NftMarket *NftMarketCallerSession) AdminAddress() (common.Address, error) {
	return _NftMarket.Contract.AdminAddress(&_NftMarket.CallOpts)
}

// CalculatePriceAndFeesForCollection is a free data retrieval call binding the contract method 0x9e0140c8.
//
// Solidity: function calculatePriceAndFeesForCollection(address collection, uint256 price) view returns(uint256 netPrice, uint256 tradingFee, uint256 creatorFee)
func (_NftMarket *NftMarketCaller) CalculatePriceAndFeesForCollection(opts *bind.CallOpts, collection common.Address, price *big.Int) (struct {
	NetPrice   *big.Int
	TradingFee *big.Int
	CreatorFee *big.Int
}, error) {
	var out []interface{}
	err := _NftMarket.contract.Call(opts, &out, "calculatePriceAndFeesForCollection", collection, price)

	outstruct := new(struct {
		NetPrice   *big.Int
		TradingFee *big.Int
		CreatorFee *big.Int
	})
	if err != nil {
		return *outstruct, err
	}

	outstruct.NetPrice = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
	outstruct.TradingFee = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int)
	outstruct.CreatorFee = *abi.ConvertType(out[2], new(*big.Int)).(**big.Int)

	return *outstruct, err

}

// CalculatePriceAndFeesForCollection is a free data retrieval call binding the contract method 0x9e0140c8.
//
// Solidity: function calculatePriceAndFeesForCollection(address collection, uint256 price) view returns(uint256 netPrice, uint256 tradingFee, uint256 creatorFee)
func (_NftMarket *NftMarketSession) CalculatePriceAndFeesForCollection(collection common.Address, price *big.Int) (struct {
	NetPrice   *big.Int
	TradingFee *big.Int
	CreatorFee *big.Int
}, error) {
	return _NftMarket.Contract.CalculatePriceAndFeesForCollection(&_NftMarket.CallOpts, collection, price)
}

// CalculatePriceAndFeesForCollection is a free data retrieval call binding the contract method 0x9e0140c8.
//
// Solidity: function calculatePriceAndFeesForCollection(address collection, uint256 price) view returns(uint256 netPrice, uint256 tradingFee, uint256 creatorFee)
func (_NftMarket *NftMarketCallerSession) CalculatePriceAndFeesForCollection(collection common.Address, price *big.Int) (struct {
	NetPrice   *big.Int
	TradingFee *big.Int
	CreatorFee *big.Int
}, error) {
	return _NftMarket.Contract.CalculatePriceAndFeesForCollection(&_NftMarket.CallOpts, collection, price)
}

// CanTokensBeListed is a free data retrieval call binding the contract method 0xc5d4618e.
//
// Solidity: function canTokensBeListed(address _collection, uint256[] _tokenIds) view returns(bool[] listingStatuses)
func (_NftMarket *NftMarketCaller) CanTokensBeListed(opts *bind.CallOpts, _collection common.Address, _tokenIds []*big.Int) ([]bool, error) {
	var out []interface{}
	err := _NftMarket.contract.Call(opts, &out, "canTokensBeListed", _collection, _tokenIds)

	if err != nil {
		return *new([]bool), err
	}

	out0 := *abi.ConvertType(out[0], new([]bool)).(*[]bool)

	return out0, err

}

// CanTokensBeListed is a free data retrieval call binding the contract method 0xc5d4618e.
//
// Solidity: function canTokensBeListed(address _collection, uint256[] _tokenIds) view returns(bool[] listingStatuses)
func (_NftMarket *NftMarketSession) CanTokensBeListed(_collection common.Address, _tokenIds []*big.Int) ([]bool, error) {
	return _NftMarket.Contract.CanTokensBeListed(&_NftMarket.CallOpts, _collection, _tokenIds)
}

// CanTokensBeListed is a free data retrieval call binding the contract method 0xc5d4618e.
//
// Solidity: function canTokensBeListed(address _collection, uint256[] _tokenIds) view returns(bool[] listingStatuses)
func (_NftMarket *NftMarketCallerSession) CanTokensBeListed(_collection common.Address, _tokenIds []*big.Int) ([]bool, error) {
	return _NftMarket.Contract.CanTokensBeListed(&_NftMarket.CallOpts, _collection, _tokenIds)
}

// MaximumAskPrice is a free data retrieval call binding the contract method 0x98a5155a.
//
// Solidity: function maximumAskPrice() view returns(uint256)
func (_NftMarket *NftMarketCaller) MaximumAskPrice(opts *bind.CallOpts) (*big.Int, error) {
	var out []interface{}
	err := _NftMarket.contract.Call(opts, &out, "maximumAskPrice")

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// MaximumAskPrice is a free data retrieval call binding the contract method 0x98a5155a.
//
// Solidity: function maximumAskPrice() view returns(uint256)
func (_NftMarket *NftMarketSession) MaximumAskPrice() (*big.Int, error) {
	return _NftMarket.Contract.MaximumAskPrice(&_NftMarket.CallOpts)
}

// MaximumAskPrice is a free data retrieval call binding the contract method 0x98a5155a.
//
// Solidity: function maximumAskPrice() view returns(uint256)
func (_NftMarket *NftMarketCallerSession) MaximumAskPrice() (*big.Int, error) {
	return _NftMarket.Contract.MaximumAskPrice(&_NftMarket.CallOpts)
}

// MinimumAskPrice is a free data retrieval call binding the contract method 0x4f06d441.
//
// Solidity: function minimumAskPrice() view returns(uint256)
func (_NftMarket *NftMarketCaller) MinimumAskPrice(opts *bind.CallOpts) (*big.Int, error) {
	var out []interface{}
	err := _NftMarket.contract.Call(opts, &out, "minimumAskPrice")

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// MinimumAskPrice is a free data retrieval call binding the contract method 0x4f06d441.
//
// Solidity: function minimumAskPrice() view returns(uint256)
func (_NftMarket *NftMarketSession) MinimumAskPrice() (*big.Int, error) {
	return _NftMarket.Contract.MinimumAskPrice(&_NftMarket.CallOpts)
}

// MinimumAskPrice is a free data retrieval call binding the contract method 0x4f06d441.
//
// Solidity: function minimumAskPrice() view returns(uint256)
func (_NftMarket *NftMarketCallerSession) MinimumAskPrice() (*big.Int, error) {
	return _NftMarket.Contract.MinimumAskPrice(&_NftMarket.CallOpts)
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() view returns(address)
func (_NftMarket *NftMarketCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
	var out []interface{}
	err := _NftMarket.contract.Call(opts, &out, "owner")

	if err != nil {
		return *new(common.Address), err
	}

	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)

	return out0, err

}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() view returns(address)
func (_NftMarket *NftMarketSession) Owner() (common.Address, error) {
	return _NftMarket.Contract.Owner(&_NftMarket.CallOpts)
}

// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
//
// Solidity: function owner() view returns(address)
func (_NftMarket *NftMarketCallerSession) Owner() (common.Address, error) {
	return _NftMarket.Contract.Owner(&_NftMarket.CallOpts)
}

// PendingRevenue is a free data retrieval call binding the contract method 0x20b6b2fc.
//
// Solidity: function pendingRevenue(address ) view returns(uint256)
func (_NftMarket *NftMarketCaller) PendingRevenue(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) {
	var out []interface{}
	err := _NftMarket.contract.Call(opts, &out, "pendingRevenue", arg0)

	if err != nil {
		return *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)

	return out0, err

}

// PendingRevenue is a free data retrieval call binding the contract method 0x20b6b2fc.
//
// Solidity: function pendingRevenue(address ) view returns(uint256)
func (_NftMarket *NftMarketSession) PendingRevenue(arg0 common.Address) (*big.Int, error) {
	return _NftMarket.Contract.PendingRevenue(&_NftMarket.CallOpts, arg0)
}

// PendingRevenue is a free data retrieval call binding the contract method 0x20b6b2fc.
//
// Solidity: function pendingRevenue(address ) view returns(uint256)
func (_NftMarket *NftMarketCallerSession) PendingRevenue(arg0 common.Address) (*big.Int, error) {
	return _NftMarket.Contract.PendingRevenue(&_NftMarket.CallOpts, arg0)
}

// TreasuryAddress is a free data retrieval call binding the contract method 0xc5f956af.
//
// Solidity: function treasuryAddress() view returns(address)
func (_NftMarket *NftMarketCaller) TreasuryAddress(opts *bind.CallOpts) (common.Address, error) {
	var out []interface{}
	err := _NftMarket.contract.Call(opts, &out, "treasuryAddress")

	if err != nil {
		return *new(common.Address), err
	}

	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)

	return out0, err

}

// TreasuryAddress is a free data retrieval call binding the contract method 0xc5f956af.
//
// Solidity: function treasuryAddress() view returns(address)
func (_NftMarket *NftMarketSession) TreasuryAddress() (common.Address, error) {
	return _NftMarket.Contract.TreasuryAddress(&_NftMarket.CallOpts)
}

// TreasuryAddress is a free data retrieval call binding the contract method 0xc5f956af.
//
// Solidity: function treasuryAddress() view returns(address)
func (_NftMarket *NftMarketCallerSession) TreasuryAddress() (common.Address, error) {
	return _NftMarket.Contract.TreasuryAddress(&_NftMarket.CallOpts)
}

// ViewAsksByCollection is a free data retrieval call binding the contract method 0x84a40864.
//
// Solidity: function viewAsksByCollection(address collection, uint256 cursor, uint256 size) view returns(uint256[] tokenIds, (address,uint256)[] askInfo, uint256)
func (_NftMarket *NftMarketCaller) ViewAsksByCollection(opts *bind.CallOpts, collection common.Address, cursor *big.Int, size *big.Int) ([]*big.Int, []ERC721NFTMarketV1Ask, *big.Int, error) {
	var out []interface{}
	err := _NftMarket.contract.Call(opts, &out, "viewAsksByCollection", collection, cursor, size)

	if err != nil {
		return *new([]*big.Int), *new([]ERC721NFTMarketV1Ask), *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int)
	out1 := *abi.ConvertType(out[1], new([]ERC721NFTMarketV1Ask)).(*[]ERC721NFTMarketV1Ask)
	out2 := *abi.ConvertType(out[2], new(*big.Int)).(**big.Int)

	return out0, out1, out2, err

}

// ViewAsksByCollection is a free data retrieval call binding the contract method 0x84a40864.
//
// Solidity: function viewAsksByCollection(address collection, uint256 cursor, uint256 size) view returns(uint256[] tokenIds, (address,uint256)[] askInfo, uint256)
func (_NftMarket *NftMarketSession) ViewAsksByCollection(collection common.Address, cursor *big.Int, size *big.Int) ([]*big.Int, []ERC721NFTMarketV1Ask, *big.Int, error) {
	return _NftMarket.Contract.ViewAsksByCollection(&_NftMarket.CallOpts, collection, cursor, size)
}

// ViewAsksByCollection is a free data retrieval call binding the contract method 0x84a40864.
//
// Solidity: function viewAsksByCollection(address collection, uint256 cursor, uint256 size) view returns(uint256[] tokenIds, (address,uint256)[] askInfo, uint256)
func (_NftMarket *NftMarketCallerSession) ViewAsksByCollection(collection common.Address, cursor *big.Int, size *big.Int) ([]*big.Int, []ERC721NFTMarketV1Ask, *big.Int, error) {
	return _NftMarket.Contract.ViewAsksByCollection(&_NftMarket.CallOpts, collection, cursor, size)
}

// ViewAsksByCollectionAndSeller is a free data retrieval call binding the contract method 0xd286ef74.
//
// Solidity: function viewAsksByCollectionAndSeller(address collection, address seller, uint256 cursor, uint256 size) view returns(uint256[] tokenIds, (address,uint256)[] askInfo, uint256)
func (_NftMarket *NftMarketCaller) ViewAsksByCollectionAndSeller(opts *bind.CallOpts, collection common.Address, seller common.Address, cursor *big.Int, size *big.Int) ([]*big.Int, []ERC721NFTMarketV1Ask, *big.Int, error) {
	var out []interface{}
	err := _NftMarket.contract.Call(opts, &out, "viewAsksByCollectionAndSeller", collection, seller, cursor, size)

	if err != nil {
		return *new([]*big.Int), *new([]ERC721NFTMarketV1Ask), *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int)
	out1 := *abi.ConvertType(out[1], new([]ERC721NFTMarketV1Ask)).(*[]ERC721NFTMarketV1Ask)
	out2 := *abi.ConvertType(out[2], new(*big.Int)).(**big.Int)

	return out0, out1, out2, err

}

// ViewAsksByCollectionAndSeller is a free data retrieval call binding the contract method 0xd286ef74.
//
// Solidity: function viewAsksByCollectionAndSeller(address collection, address seller, uint256 cursor, uint256 size) view returns(uint256[] tokenIds, (address,uint256)[] askInfo, uint256)
func (_NftMarket *NftMarketSession) ViewAsksByCollectionAndSeller(collection common.Address, seller common.Address, cursor *big.Int, size *big.Int) ([]*big.Int, []ERC721NFTMarketV1Ask, *big.Int, error) {
	return _NftMarket.Contract.ViewAsksByCollectionAndSeller(&_NftMarket.CallOpts, collection, seller, cursor, size)
}

// ViewAsksByCollectionAndSeller is a free data retrieval call binding the contract method 0xd286ef74.
//
// Solidity: function viewAsksByCollectionAndSeller(address collection, address seller, uint256 cursor, uint256 size) view returns(uint256[] tokenIds, (address,uint256)[] askInfo, uint256)
func (_NftMarket *NftMarketCallerSession) ViewAsksByCollectionAndSeller(collection common.Address, seller common.Address, cursor *big.Int, size *big.Int) ([]*big.Int, []ERC721NFTMarketV1Ask, *big.Int, error) {
	return _NftMarket.Contract.ViewAsksByCollectionAndSeller(&_NftMarket.CallOpts, collection, seller, cursor, size)
}

// ViewAsksByCollectionAndTokenIds is a free data retrieval call binding the contract method 0x22f67b6d.
//
// Solidity: function viewAsksByCollectionAndTokenIds(address collection, uint256[] tokenIds) view returns(bool[] statuses, (address,uint256)[] askInfo)
func (_NftMarket *NftMarketCaller) ViewAsksByCollectionAndTokenIds(opts *bind.CallOpts, collection common.Address, tokenIds []*big.Int) (struct {
	Statuses []bool
	AskInfo  []ERC721NFTMarketV1Ask
}, error) {
	var out []interface{}
	err := _NftMarket.contract.Call(opts, &out, "viewAsksByCollectionAndTokenIds", collection, tokenIds)

	outstruct := new(struct {
		Statuses []bool
		AskInfo  []ERC721NFTMarketV1Ask
	})
	if err != nil {
		return *outstruct, err
	}

	outstruct.Statuses = *abi.ConvertType(out[0], new([]bool)).(*[]bool)
	outstruct.AskInfo = *abi.ConvertType(out[1], new([]ERC721NFTMarketV1Ask)).(*[]ERC721NFTMarketV1Ask)

	return *outstruct, err

}

// ViewAsksByCollectionAndTokenIds is a free data retrieval call binding the contract method 0x22f67b6d.
//
// Solidity: function viewAsksByCollectionAndTokenIds(address collection, uint256[] tokenIds) view returns(bool[] statuses, (address,uint256)[] askInfo)
func (_NftMarket *NftMarketSession) ViewAsksByCollectionAndTokenIds(collection common.Address, tokenIds []*big.Int) (struct {
	Statuses []bool
	AskInfo  []ERC721NFTMarketV1Ask
}, error) {
	return _NftMarket.Contract.ViewAsksByCollectionAndTokenIds(&_NftMarket.CallOpts, collection, tokenIds)
}

// ViewAsksByCollectionAndTokenIds is a free data retrieval call binding the contract method 0x22f67b6d.
//
// Solidity: function viewAsksByCollectionAndTokenIds(address collection, uint256[] tokenIds) view returns(bool[] statuses, (address,uint256)[] askInfo)
func (_NftMarket *NftMarketCallerSession) ViewAsksByCollectionAndTokenIds(collection common.Address, tokenIds []*big.Int) (struct {
	Statuses []bool
	AskInfo  []ERC721NFTMarketV1Ask
}, error) {
	return _NftMarket.Contract.ViewAsksByCollectionAndTokenIds(&_NftMarket.CallOpts, collection, tokenIds)
}

// ViewCollections is a free data retrieval call binding the contract method 0x51c383ea.
//
// Solidity: function viewCollections(uint256 cursor, uint256 size) view returns(address[] collectionAddresses, (uint8,address,address,uint256,uint256)[] collectionDetails, uint256)
func (_NftMarket *NftMarketCaller) ViewCollections(opts *bind.CallOpts, cursor *big.Int, size *big.Int) ([]common.Address, []ERC721NFTMarketV1Collection, *big.Int, error) {
	var out []interface{}
	err := _NftMarket.contract.Call(opts, &out, "viewCollections", cursor, size)

	if err != nil {
		return *new([]common.Address), *new([]ERC721NFTMarketV1Collection), *new(*big.Int), err
	}

	out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address)
	out1 := *abi.ConvertType(out[1], new([]ERC721NFTMarketV1Collection)).(*[]ERC721NFTMarketV1Collection)
	out2 := *abi.ConvertType(out[2], new(*big.Int)).(**big.Int)

	return out0, out1, out2, err

}

// ViewCollections is a free data retrieval call binding the contract method 0x51c383ea.
//
// Solidity: function viewCollections(uint256 cursor, uint256 size) view returns(address[] collectionAddresses, (uint8,address,address,uint256,uint256)[] collectionDetails, uint256)
func (_NftMarket *NftMarketSession) ViewCollections(cursor *big.Int, size *big.Int) ([]common.Address, []ERC721NFTMarketV1Collection, *big.Int, error) {
	return _NftMarket.Contract.ViewCollections(&_NftMarket.CallOpts, cursor, size)
}

// ViewCollections is a free data retrieval call binding the contract method 0x51c383ea.
//
// Solidity: function viewCollections(uint256 cursor, uint256 size) view returns(address[] collectionAddresses, (uint8,address,address,uint256,uint256)[] collectionDetails, uint256)
func (_NftMarket *NftMarketCallerSession) ViewCollections(cursor *big.Int, size *big.Int) ([]common.Address, []ERC721NFTMarketV1Collection, *big.Int, error) {
	return _NftMarket.Contract.ViewCollections(&_NftMarket.CallOpts, cursor, size)
}

// AddCollection is a paid mutator transaction binding the contract method 0xe17734a3.
//
// Solidity: function addCollection(address _collection, address _creator, address _whitelistChecker, uint256 _tradingFee, uint256 _creatorFee) returns()
func (_NftMarket *NftMarketTransactor) AddCollection(opts *bind.TransactOpts, _collection common.Address, _creator common.Address, _whitelistChecker common.Address, _tradingFee *big.Int, _creatorFee *big.Int) (*types.Transaction, error) {
	return _NftMarket.contract.Transact(opts, "addCollection", _collection, _creator, _whitelistChecker, _tradingFee, _creatorFee)
}

// AddCollection is a paid mutator transaction binding the contract method 0xe17734a3.
//
// Solidity: function addCollection(address _collection, address _creator, address _whitelistChecker, uint256 _tradingFee, uint256 _creatorFee) returns()
func (_NftMarket *NftMarketSession) AddCollection(_collection common.Address, _creator common.Address, _whitelistChecker common.Address, _tradingFee *big.Int, _creatorFee *big.Int) (*types.Transaction, error) {
	return _NftMarket.Contract.AddCollection(&_NftMarket.TransactOpts, _collection, _creator, _whitelistChecker, _tradingFee, _creatorFee)
}

// AddCollection is a paid mutator transaction binding the contract method 0xe17734a3.
//
// Solidity: function addCollection(address _collection, address _creator, address _whitelistChecker, uint256 _tradingFee, uint256 _creatorFee) returns()
func (_NftMarket *NftMarketTransactorSession) AddCollection(_collection common.Address, _creator common.Address, _whitelistChecker common.Address, _tradingFee *big.Int, _creatorFee *big.Int) (*types.Transaction, error) {
	return _NftMarket.Contract.AddCollection(&_NftMarket.TransactOpts, _collection, _creator, _whitelistChecker, _tradingFee, _creatorFee)
}

// BuyTokenUsingBNB is a paid mutator transaction binding the contract method 0xfb9fe938.
//
// Solidity: function buyTokenUsingBNB(address _collection, uint256 _tokenId) payable returns()
func (_NftMarket *NftMarketTransactor) BuyTokenUsingBNB(opts *bind.TransactOpts, _collection common.Address, _tokenId *big.Int) (*types.Transaction, error) {
	return _NftMarket.contract.Transact(opts, "buyTokenUsingBNB", _collection, _tokenId)
}

// BuyTokenUsingBNB is a paid mutator transaction binding the contract method 0xfb9fe938.
//
// Solidity: function buyTokenUsingBNB(address _collection, uint256 _tokenId) payable returns()
func (_NftMarket *NftMarketSession) BuyTokenUsingBNB(_collection common.Address, _tokenId *big.Int) (*types.Transaction, error) {
	return _NftMarket.Contract.BuyTokenUsingBNB(&_NftMarket.TransactOpts, _collection, _tokenId)
}

// BuyTokenUsingBNB is a paid mutator transaction binding the contract method 0xfb9fe938.
//
// Solidity: function buyTokenUsingBNB(address _collection, uint256 _tokenId) payable returns()
func (_NftMarket *NftMarketTransactorSession) BuyTokenUsingBNB(_collection common.Address, _tokenId *big.Int) (*types.Transaction, error) {
	return _NftMarket.Contract.BuyTokenUsingBNB(&_NftMarket.TransactOpts, _collection, _tokenId)
}

// BuyTokenUsingWBNB is a paid mutator transaction binding the contract method 0xed140e86.
//
// Solidity: function buyTokenUsingWBNB(address _collection, uint256 _tokenId, uint256 _price) returns()
func (_NftMarket *NftMarketTransactor) BuyTokenUsingWBNB(opts *bind.TransactOpts, _collection common.Address, _tokenId *big.Int, _price *big.Int) (*types.Transaction, error) {
	return _NftMarket.contract.Transact(opts, "buyTokenUsingWBNB", _collection, _tokenId, _price)
}

// BuyTokenUsingWBNB is a paid mutator transaction binding the contract method 0xed140e86.
//
// Solidity: function buyTokenUsingWBNB(address _collection, uint256 _tokenId, uint256 _price) returns()
func (_NftMarket *NftMarketSession) BuyTokenUsingWBNB(_collection common.Address, _tokenId *big.Int, _price *big.Int) (*types.Transaction, error) {
	return _NftMarket.Contract.BuyTokenUsingWBNB(&_NftMarket.TransactOpts, _collection, _tokenId, _price)
}

// BuyTokenUsingWBNB is a paid mutator transaction binding the contract method 0xed140e86.
//
// Solidity: function buyTokenUsingWBNB(address _collection, uint256 _tokenId, uint256 _price) returns()
func (_NftMarket *NftMarketTransactorSession) BuyTokenUsingWBNB(_collection common.Address, _tokenId *big.Int, _price *big.Int) (*types.Transaction, error) {
	return _NftMarket.Contract.BuyTokenUsingWBNB(&_NftMarket.TransactOpts, _collection, _tokenId, _price)
}

// CancelAskOrder is a paid mutator transaction binding the contract method 0x95f42098.
//
// Solidity: function cancelAskOrder(address _collection, uint256 _tokenId) returns()
func (_NftMarket *NftMarketTransactor) CancelAskOrder(opts *bind.TransactOpts, _collection common.Address, _tokenId *big.Int) (*types.Transaction, error) {
	return _NftMarket.contract.Transact(opts, "cancelAskOrder", _collection, _tokenId)
}

// CancelAskOrder is a paid mutator transaction binding the contract method 0x95f42098.
//
// Solidity: function cancelAskOrder(address _collection, uint256 _tokenId) returns()
func (_NftMarket *NftMarketSession) CancelAskOrder(_collection common.Address, _tokenId *big.Int) (*types.Transaction, error) {
	return _NftMarket.Contract.CancelAskOrder(&_NftMarket.TransactOpts, _collection, _tokenId)
}

// CancelAskOrder is a paid mutator transaction binding the contract method 0x95f42098.
//
// Solidity: function cancelAskOrder(address _collection, uint256 _tokenId) returns()
func (_NftMarket *NftMarketTransactorSession) CancelAskOrder(_collection common.Address, _tokenId *big.Int) (*types.Transaction, error) {
	return _NftMarket.Contract.CancelAskOrder(&_NftMarket.TransactOpts, _collection, _tokenId)
}

// ClaimPendingRevenue is a paid mutator transaction binding the contract method 0xb6c1d2cf.
//
// Solidity: function claimPendingRevenue() returns()
func (_NftMarket *NftMarketTransactor) ClaimPendingRevenue(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _NftMarket.contract.Transact(opts, "claimPendingRevenue")
}

// ClaimPendingRevenue is a paid mutator transaction binding the contract method 0xb6c1d2cf.
//
// Solidity: function claimPendingRevenue() returns()
func (_NftMarket *NftMarketSession) ClaimPendingRevenue() (*types.Transaction, error) {
	return _NftMarket.Contract.ClaimPendingRevenue(&_NftMarket.TransactOpts)
}

// ClaimPendingRevenue is a paid mutator transaction binding the contract method 0xb6c1d2cf.
//
// Solidity: function claimPendingRevenue() returns()
func (_NftMarket *NftMarketTransactorSession) ClaimPendingRevenue() (*types.Transaction, error) {
	return _NftMarket.Contract.ClaimPendingRevenue(&_NftMarket.TransactOpts)
}

// CloseCollectionForTradingAndListing is a paid mutator transaction binding the contract method 0xddf9ba6f.
//
// Solidity: function closeCollectionForTradingAndListing(address _collection) returns()
func (_NftMarket *NftMarketTransactor) CloseCollectionForTradingAndListing(opts *bind.TransactOpts, _collection common.Address) (*types.Transaction, error) {
	return _NftMarket.contract.Transact(opts, "closeCollectionForTradingAndListing", _collection)
}

// CloseCollectionForTradingAndListing is a paid mutator transaction binding the contract method 0xddf9ba6f.
//
// Solidity: function closeCollectionForTradingAndListing(address _collection) returns()
func (_NftMarket *NftMarketSession) CloseCollectionForTradingAndListing(_collection common.Address) (*types.Transaction, error) {
	return _NftMarket.Contract.CloseCollectionForTradingAndListing(&_NftMarket.TransactOpts, _collection)
}

// CloseCollectionForTradingAndListing is a paid mutator transaction binding the contract method 0xddf9ba6f.
//
// Solidity: function closeCollectionForTradingAndListing(address _collection) returns()
func (_NftMarket *NftMarketTransactorSession) CloseCollectionForTradingAndListing(_collection common.Address) (*types.Transaction, error) {
	return _NftMarket.Contract.CloseCollectionForTradingAndListing(&_NftMarket.TransactOpts, _collection)
}

// CreateAskOrder is a paid mutator transaction binding the contract method 0x803b64a1.
//
// Solidity: function createAskOrder(address _collection, uint256 _tokenId, uint256 _askPrice) returns()
func (_NftMarket *NftMarketTransactor) CreateAskOrder(opts *bind.TransactOpts, _collection common.Address, _tokenId *big.Int, _askPrice *big.Int) (*types.Transaction, error) {
	return _NftMarket.contract.Transact(opts, "createAskOrder", _collection, _tokenId, _askPrice)
}

// CreateAskOrder is a paid mutator transaction binding the contract method 0x803b64a1.
//
// Solidity: function createAskOrder(address _collection, uint256 _tokenId, uint256 _askPrice) returns()
func (_NftMarket *NftMarketSession) CreateAskOrder(_collection common.Address, _tokenId *big.Int, _askPrice *big.Int) (*types.Transaction, error) {
	return _NftMarket.Contract.CreateAskOrder(&_NftMarket.TransactOpts, _collection, _tokenId, _askPrice)
}

// CreateAskOrder is a paid mutator transaction binding the contract method 0x803b64a1.
//
// Solidity: function createAskOrder(address _collection, uint256 _tokenId, uint256 _askPrice) returns()
func (_NftMarket *NftMarketTransactorSession) CreateAskOrder(_collection common.Address, _tokenId *big.Int, _askPrice *big.Int) (*types.Transaction, error) {
	return _NftMarket.Contract.CreateAskOrder(&_NftMarket.TransactOpts, _collection, _tokenId, _askPrice)
}

// ModifyAskOrder is a paid mutator transaction binding the contract method 0x9b2adcdc.
//
// Solidity: function modifyAskOrder(address _collection, uint256 _tokenId, uint256 _newPrice) returns()
func (_NftMarket *NftMarketTransactor) ModifyAskOrder(opts *bind.TransactOpts, _collection common.Address, _tokenId *big.Int, _newPrice *big.Int) (*types.Transaction, error) {
	return _NftMarket.contract.Transact(opts, "modifyAskOrder", _collection, _tokenId, _newPrice)
}

// ModifyAskOrder is a paid mutator transaction binding the contract method 0x9b2adcdc.
//
// Solidity: function modifyAskOrder(address _collection, uint256 _tokenId, uint256 _newPrice) returns()
func (_NftMarket *NftMarketSession) ModifyAskOrder(_collection common.Address, _tokenId *big.Int, _newPrice *big.Int) (*types.Transaction, error) {
	return _NftMarket.Contract.ModifyAskOrder(&_NftMarket.TransactOpts, _collection, _tokenId, _newPrice)
}

// ModifyAskOrder is a paid mutator transaction binding the contract method 0x9b2adcdc.
//
// Solidity: function modifyAskOrder(address _collection, uint256 _tokenId, uint256 _newPrice) returns()
func (_NftMarket *NftMarketTransactorSession) ModifyAskOrder(_collection common.Address, _tokenId *big.Int, _newPrice *big.Int) (*types.Transaction, error) {
	return _NftMarket.Contract.ModifyAskOrder(&_NftMarket.TransactOpts, _collection, _tokenId, _newPrice)
}

// ModifyCollection is a paid mutator transaction binding the contract method 0x6b248032.
//
// Solidity: function modifyCollection(address _collection, address _creator, address _whitelistChecker, uint256 _tradingFee, uint256 _creatorFee) returns()
func (_NftMarket *NftMarketTransactor) ModifyCollection(opts *bind.TransactOpts, _collection common.Address, _creator common.Address, _whitelistChecker common.Address, _tradingFee *big.Int, _creatorFee *big.Int) (*types.Transaction, error) {
	return _NftMarket.contract.Transact(opts, "modifyCollection", _collection, _creator, _whitelistChecker, _tradingFee, _creatorFee)
}

// ModifyCollection is a paid mutator transaction binding the contract method 0x6b248032.
//
// Solidity: function modifyCollection(address _collection, address _creator, address _whitelistChecker, uint256 _tradingFee, uint256 _creatorFee) returns()
func (_NftMarket *NftMarketSession) ModifyCollection(_collection common.Address, _creator common.Address, _whitelistChecker common.Address, _tradingFee *big.Int, _creatorFee *big.Int) (*types.Transaction, error) {
	return _NftMarket.Contract.ModifyCollection(&_NftMarket.TransactOpts, _collection, _creator, _whitelistChecker, _tradingFee, _creatorFee)
}

// ModifyCollection is a paid mutator transaction binding the contract method 0x6b248032.
//
// Solidity: function modifyCollection(address _collection, address _creator, address _whitelistChecker, uint256 _tradingFee, uint256 _creatorFee) returns()
func (_NftMarket *NftMarketTransactorSession) ModifyCollection(_collection common.Address, _creator common.Address, _whitelistChecker common.Address, _tradingFee *big.Int, _creatorFee *big.Int) (*types.Transaction, error) {
	return _NftMarket.Contract.ModifyCollection(&_NftMarket.TransactOpts, _collection, _creator, _whitelistChecker, _tradingFee, _creatorFee)
}

// OnERC721Received is a paid mutator transaction binding the contract method 0x150b7a02.
//
// Solidity: function onERC721Received(address , address , uint256 , bytes ) returns(bytes4)
func (_NftMarket *NftMarketTransactor) OnERC721Received(opts *bind.TransactOpts, arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 []byte) (*types.Transaction, error) {
	return _NftMarket.contract.Transact(opts, "onERC721Received", arg0, arg1, arg2, arg3)
}

// OnERC721Received is a paid mutator transaction binding the contract method 0x150b7a02.
//
// Solidity: function onERC721Received(address , address , uint256 , bytes ) returns(bytes4)
func (_NftMarket *NftMarketSession) OnERC721Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 []byte) (*types.Transaction, error) {
	return _NftMarket.Contract.OnERC721Received(&_NftMarket.TransactOpts, arg0, arg1, arg2, arg3)
}

// OnERC721Received is a paid mutator transaction binding the contract method 0x150b7a02.
//
// Solidity: function onERC721Received(address , address , uint256 , bytes ) returns(bytes4)
func (_NftMarket *NftMarketTransactorSession) OnERC721Received(arg0 common.Address, arg1 common.Address, arg2 *big.Int, arg3 []byte) (*types.Transaction, error) {
	return _NftMarket.Contract.OnERC721Received(&_NftMarket.TransactOpts, arg0, arg1, arg2, arg3)
}

// RecoverFungibleTokens is a paid mutator transaction binding the contract method 0x3ffd1781.
//
// Solidity: function recoverFungibleTokens(address _token) returns()
func (_NftMarket *NftMarketTransactor) RecoverFungibleTokens(opts *bind.TransactOpts, _token common.Address) (*types.Transaction, error) {
	return _NftMarket.contract.Transact(opts, "recoverFungibleTokens", _token)
}

// RecoverFungibleTokens is a paid mutator transaction binding the contract method 0x3ffd1781.
//
// Solidity: function recoverFungibleTokens(address _token) returns()
func (_NftMarket *NftMarketSession) RecoverFungibleTokens(_token common.Address) (*types.Transaction, error) {
	return _NftMarket.Contract.RecoverFungibleTokens(&_NftMarket.TransactOpts, _token)
}

// RecoverFungibleTokens is a paid mutator transaction binding the contract method 0x3ffd1781.
//
// Solidity: function recoverFungibleTokens(address _token) returns()
func (_NftMarket *NftMarketTransactorSession) RecoverFungibleTokens(_token common.Address) (*types.Transaction, error) {
	return _NftMarket.Contract.RecoverFungibleTokens(&_NftMarket.TransactOpts, _token)
}

// RecoverNonFungibleToken is a paid mutator transaction binding the contract method 0xbb0fd147.
//
// Solidity: function recoverNonFungibleToken(address _token, uint256 _tokenId) returns()
func (_NftMarket *NftMarketTransactor) RecoverNonFungibleToken(opts *bind.TransactOpts, _token common.Address, _tokenId *big.Int) (*types.Transaction, error) {
	return _NftMarket.contract.Transact(opts, "recoverNonFungibleToken", _token, _tokenId)
}

// RecoverNonFungibleToken is a paid mutator transaction binding the contract method 0xbb0fd147.
//
// Solidity: function recoverNonFungibleToken(address _token, uint256 _tokenId) returns()
func (_NftMarket *NftMarketSession) RecoverNonFungibleToken(_token common.Address, _tokenId *big.Int) (*types.Transaction, error) {
	return _NftMarket.Contract.RecoverNonFungibleToken(&_NftMarket.TransactOpts, _token, _tokenId)
}

// RecoverNonFungibleToken is a paid mutator transaction binding the contract method 0xbb0fd147.
//
// Solidity: function recoverNonFungibleToken(address _token, uint256 _tokenId) returns()
func (_NftMarket *NftMarketTransactorSession) RecoverNonFungibleToken(_token common.Address, _tokenId *big.Int) (*types.Transaction, error) {
	return _NftMarket.Contract.RecoverNonFungibleToken(&_NftMarket.TransactOpts, _token, _tokenId)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_NftMarket *NftMarketTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
	return _NftMarket.contract.Transact(opts, "renounceOwnership")
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_NftMarket *NftMarketSession) RenounceOwnership() (*types.Transaction, error) {
	return _NftMarket.Contract.RenounceOwnership(&_NftMarket.TransactOpts)
}

// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
//
// Solidity: function renounceOwnership() returns()
func (_NftMarket *NftMarketTransactorSession) RenounceOwnership() (*types.Transaction, error) {
	return _NftMarket.Contract.RenounceOwnership(&_NftMarket.TransactOpts)
}

// SetAdminAndTreasuryAddresses is a paid mutator transaction binding the contract method 0x791e8018.
//
// Solidity: function setAdminAndTreasuryAddresses(address _adminAddress, address _treasuryAddress) returns()
func (_NftMarket *NftMarketTransactor) SetAdminAndTreasuryAddresses(opts *bind.TransactOpts, _adminAddress common.Address, _treasuryAddress common.Address) (*types.Transaction, error) {
	return _NftMarket.contract.Transact(opts, "setAdminAndTreasuryAddresses", _adminAddress, _treasuryAddress)
}

// SetAdminAndTreasuryAddresses is a paid mutator transaction binding the contract method 0x791e8018.
//
// Solidity: function setAdminAndTreasuryAddresses(address _adminAddress, address _treasuryAddress) returns()
func (_NftMarket *NftMarketSession) SetAdminAndTreasuryAddresses(_adminAddress common.Address, _treasuryAddress common.Address) (*types.Transaction, error) {
	return _NftMarket.Contract.SetAdminAndTreasuryAddresses(&_NftMarket.TransactOpts, _adminAddress, _treasuryAddress)
}

// SetAdminAndTreasuryAddresses is a paid mutator transaction binding the contract method 0x791e8018.
//
// Solidity: function setAdminAndTreasuryAddresses(address _adminAddress, address _treasuryAddress) returns()
func (_NftMarket *NftMarketTransactorSession) SetAdminAndTreasuryAddresses(_adminAddress common.Address, _treasuryAddress common.Address) (*types.Transaction, error) {
	return _NftMarket.Contract.SetAdminAndTreasuryAddresses(&_NftMarket.TransactOpts, _adminAddress, _treasuryAddress)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_NftMarket *NftMarketTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
	return _NftMarket.contract.Transact(opts, "transferOwnership", newOwner)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_NftMarket *NftMarketSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
	return _NftMarket.Contract.TransferOwnership(&_NftMarket.TransactOpts, newOwner)
}

// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
//
// Solidity: function transferOwnership(address newOwner) returns()
func (_NftMarket *NftMarketTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
	return _NftMarket.Contract.TransferOwnership(&_NftMarket.TransactOpts, newOwner)
}

// UpdateMinimumAndMaximumPrices is a paid mutator transaction binding the contract method 0xb2ea3931.
//
// Solidity: function updateMinimumAndMaximumPrices(uint256 _minimumAskPrice, uint256 _maximumAskPrice) returns()
func (_NftMarket *NftMarketTransactor) UpdateMinimumAndMaximumPrices(opts *bind.TransactOpts, _minimumAskPrice *big.Int, _maximumAskPrice *big.Int) (*types.Transaction, error) {
	return _NftMarket.contract.Transact(opts, "updateMinimumAndMaximumPrices", _minimumAskPrice, _maximumAskPrice)
}

// UpdateMinimumAndMaximumPrices is a paid mutator transaction binding the contract method 0xb2ea3931.
//
// Solidity: function updateMinimumAndMaximumPrices(uint256 _minimumAskPrice, uint256 _maximumAskPrice) returns()
func (_NftMarket *NftMarketSession) UpdateMinimumAndMaximumPrices(_minimumAskPrice *big.Int, _maximumAskPrice *big.Int) (*types.Transaction, error) {
	return _NftMarket.Contract.UpdateMinimumAndMaximumPrices(&_NftMarket.TransactOpts, _minimumAskPrice, _maximumAskPrice)
}

// UpdateMinimumAndMaximumPrices is a paid mutator transaction binding the contract method 0xb2ea3931.
//
// Solidity: function updateMinimumAndMaximumPrices(uint256 _minimumAskPrice, uint256 _maximumAskPrice) returns()
func (_NftMarket *NftMarketTransactorSession) UpdateMinimumAndMaximumPrices(_minimumAskPrice *big.Int, _maximumAskPrice *big.Int) (*types.Transaction, error) {
	return _NftMarket.Contract.UpdateMinimumAndMaximumPrices(&_NftMarket.TransactOpts, _minimumAskPrice, _maximumAskPrice)
}

// NftMarketAskCancelIterator is returned from FilterAskCancel and is used to iterate over the raw logs and unpacked data for AskCancel events raised by the NftMarket contract.
type NftMarketAskCancelIterator struct {
	Event *NftMarketAskCancel // 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 *NftMarketAskCancelIterator) 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(NftMarketAskCancel)
			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(NftMarketAskCancel)
		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 *NftMarketAskCancelIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *NftMarketAskCancelIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// NftMarketAskCancel represents a AskCancel event raised by the NftMarket contract.
type NftMarketAskCancel struct {
	Collection common.Address
	Seller     common.Address
	TokenId    *big.Int
	Raw        types.Log // Blockchain specific contextual infos
}

// FilterAskCancel is a free log retrieval operation binding the contract event 0xa5764ea233325154a6388255c54b9f302ec2ed8586af0a9a606cd64e88298eb7.
//
// Solidity: event AskCancel(address indexed collection, address indexed seller, uint256 indexed tokenId)
func (_NftMarket *NftMarketFilterer) FilterAskCancel(opts *bind.FilterOpts, collection []common.Address, seller []common.Address, tokenId []*big.Int) (*NftMarketAskCancelIterator, error) {

	var collectionRule []interface{}
	for _, collectionItem := range collection {
		collectionRule = append(collectionRule, collectionItem)
	}
	var sellerRule []interface{}
	for _, sellerItem := range seller {
		sellerRule = append(sellerRule, sellerItem)
	}
	var tokenIdRule []interface{}
	for _, tokenIdItem := range tokenId {
		tokenIdRule = append(tokenIdRule, tokenIdItem)
	}

	logs, sub, err := _NftMarket.contract.FilterLogs(opts, "AskCancel", collectionRule, sellerRule, tokenIdRule)
	if err != nil {
		return nil, err
	}
	return &NftMarketAskCancelIterator{contract: _NftMarket.contract, event: "AskCancel", logs: logs, sub: sub}, nil
}

// WatchAskCancel is a free log subscription operation binding the contract event 0xa5764ea233325154a6388255c54b9f302ec2ed8586af0a9a606cd64e88298eb7.
//
// Solidity: event AskCancel(address indexed collection, address indexed seller, uint256 indexed tokenId)
func (_NftMarket *NftMarketFilterer) WatchAskCancel(opts *bind.WatchOpts, sink chan<- *NftMarketAskCancel, collection []common.Address, seller []common.Address, tokenId []*big.Int) (event.Subscription, error) {

	var collectionRule []interface{}
	for _, collectionItem := range collection {
		collectionRule = append(collectionRule, collectionItem)
	}
	var sellerRule []interface{}
	for _, sellerItem := range seller {
		sellerRule = append(sellerRule, sellerItem)
	}
	var tokenIdRule []interface{}
	for _, tokenIdItem := range tokenId {
		tokenIdRule = append(tokenIdRule, tokenIdItem)
	}

	logs, sub, err := _NftMarket.contract.WatchLogs(opts, "AskCancel", collectionRule, sellerRule, 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(NftMarketAskCancel)
				if err := _NftMarket.contract.UnpackLog(event, "AskCancel", 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
}

// ParseAskCancel is a log parse operation binding the contract event 0xa5764ea233325154a6388255c54b9f302ec2ed8586af0a9a606cd64e88298eb7.
//
// Solidity: event AskCancel(address indexed collection, address indexed seller, uint256 indexed tokenId)
func (_NftMarket *NftMarketFilterer) ParseAskCancel(log types.Log) (*NftMarketAskCancel, error) {
	event := new(NftMarketAskCancel)
	if err := _NftMarket.contract.UnpackLog(event, "AskCancel", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}

// NftMarketAskNewIterator is returned from FilterAskNew and is used to iterate over the raw logs and unpacked data for AskNew events raised by the NftMarket contract.
type NftMarketAskNewIterator struct {
	Event *NftMarketAskNew // 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 *NftMarketAskNewIterator) 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(NftMarketAskNew)
			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(NftMarketAskNew)
		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 *NftMarketAskNewIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *NftMarketAskNewIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// NftMarketAskNew represents a AskNew event raised by the NftMarket contract.
type NftMarketAskNew struct {
	Collection common.Address
	Seller     common.Address
	TokenId    *big.Int
	AskPrice   *big.Int
	Raw        types.Log // Blockchain specific contextual infos
}

// FilterAskNew is a free log retrieval operation binding the contract event 0xaa0431463bb62c812c04a1e5310cf43dd9baedc7a8eab71e02f572c741467e8c.
//
// Solidity: event AskNew(address indexed collection, address indexed seller, uint256 indexed tokenId, uint256 askPrice)
func (_NftMarket *NftMarketFilterer) FilterAskNew(opts *bind.FilterOpts, collection []common.Address, seller []common.Address, tokenId []*big.Int) (*NftMarketAskNewIterator, error) {

	var collectionRule []interface{}
	for _, collectionItem := range collection {
		collectionRule = append(collectionRule, collectionItem)
	}
	var sellerRule []interface{}
	for _, sellerItem := range seller {
		sellerRule = append(sellerRule, sellerItem)
	}
	var tokenIdRule []interface{}
	for _, tokenIdItem := range tokenId {
		tokenIdRule = append(tokenIdRule, tokenIdItem)
	}

	logs, sub, err := _NftMarket.contract.FilterLogs(opts, "AskNew", collectionRule, sellerRule, tokenIdRule)
	if err != nil {
		return nil, err
	}
	return &NftMarketAskNewIterator{contract: _NftMarket.contract, event: "AskNew", logs: logs, sub: sub}, nil
}

// WatchAskNew is a free log subscription operation binding the contract event 0xaa0431463bb62c812c04a1e5310cf43dd9baedc7a8eab71e02f572c741467e8c.
//
// Solidity: event AskNew(address indexed collection, address indexed seller, uint256 indexed tokenId, uint256 askPrice)
func (_NftMarket *NftMarketFilterer) WatchAskNew(opts *bind.WatchOpts, sink chan<- *NftMarketAskNew, collection []common.Address, seller []common.Address, tokenId []*big.Int) (event.Subscription, error) {

	var collectionRule []interface{}
	for _, collectionItem := range collection {
		collectionRule = append(collectionRule, collectionItem)
	}
	var sellerRule []interface{}
	for _, sellerItem := range seller {
		sellerRule = append(sellerRule, sellerItem)
	}
	var tokenIdRule []interface{}
	for _, tokenIdItem := range tokenId {
		tokenIdRule = append(tokenIdRule, tokenIdItem)
	}

	logs, sub, err := _NftMarket.contract.WatchLogs(opts, "AskNew", collectionRule, sellerRule, 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(NftMarketAskNew)
				if err := _NftMarket.contract.UnpackLog(event, "AskNew", 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
}

// ParseAskNew is a log parse operation binding the contract event 0xaa0431463bb62c812c04a1e5310cf43dd9baedc7a8eab71e02f572c741467e8c.
//
// Solidity: event AskNew(address indexed collection, address indexed seller, uint256 indexed tokenId, uint256 askPrice)
func (_NftMarket *NftMarketFilterer) ParseAskNew(log types.Log) (*NftMarketAskNew, error) {
	event := new(NftMarketAskNew)
	if err := _NftMarket.contract.UnpackLog(event, "AskNew", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}

// NftMarketAskUpdateIterator is returned from FilterAskUpdate and is used to iterate over the raw logs and unpacked data for AskUpdate events raised by the NftMarket contract.
type NftMarketAskUpdateIterator struct {
	Event *NftMarketAskUpdate // 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 *NftMarketAskUpdateIterator) 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(NftMarketAskUpdate)
			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(NftMarketAskUpdate)
		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 *NftMarketAskUpdateIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *NftMarketAskUpdateIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// NftMarketAskUpdate represents a AskUpdate event raised by the NftMarket contract.
type NftMarketAskUpdate struct {
	Collection common.Address
	Seller     common.Address
	TokenId    *big.Int
	AskPrice   *big.Int
	Raw        types.Log // Blockchain specific contextual infos
}

// FilterAskUpdate is a free log retrieval operation binding the contract event 0x492437c0ade072acdf12e63a19d8df68bb5e414e2098dc470239df87702343ea.
//
// Solidity: event AskUpdate(address indexed collection, address indexed seller, uint256 indexed tokenId, uint256 askPrice)
func (_NftMarket *NftMarketFilterer) FilterAskUpdate(opts *bind.FilterOpts, collection []common.Address, seller []common.Address, tokenId []*big.Int) (*NftMarketAskUpdateIterator, error) {

	var collectionRule []interface{}
	for _, collectionItem := range collection {
		collectionRule = append(collectionRule, collectionItem)
	}
	var sellerRule []interface{}
	for _, sellerItem := range seller {
		sellerRule = append(sellerRule, sellerItem)
	}
	var tokenIdRule []interface{}
	for _, tokenIdItem := range tokenId {
		tokenIdRule = append(tokenIdRule, tokenIdItem)
	}

	logs, sub, err := _NftMarket.contract.FilterLogs(opts, "AskUpdate", collectionRule, sellerRule, tokenIdRule)
	if err != nil {
		return nil, err
	}
	return &NftMarketAskUpdateIterator{contract: _NftMarket.contract, event: "AskUpdate", logs: logs, sub: sub}, nil
}

// WatchAskUpdate is a free log subscription operation binding the contract event 0x492437c0ade072acdf12e63a19d8df68bb5e414e2098dc470239df87702343ea.
//
// Solidity: event AskUpdate(address indexed collection, address indexed seller, uint256 indexed tokenId, uint256 askPrice)
func (_NftMarket *NftMarketFilterer) WatchAskUpdate(opts *bind.WatchOpts, sink chan<- *NftMarketAskUpdate, collection []common.Address, seller []common.Address, tokenId []*big.Int) (event.Subscription, error) {

	var collectionRule []interface{}
	for _, collectionItem := range collection {
		collectionRule = append(collectionRule, collectionItem)
	}
	var sellerRule []interface{}
	for _, sellerItem := range seller {
		sellerRule = append(sellerRule, sellerItem)
	}
	var tokenIdRule []interface{}
	for _, tokenIdItem := range tokenId {
		tokenIdRule = append(tokenIdRule, tokenIdItem)
	}

	logs, sub, err := _NftMarket.contract.WatchLogs(opts, "AskUpdate", collectionRule, sellerRule, 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(NftMarketAskUpdate)
				if err := _NftMarket.contract.UnpackLog(event, "AskUpdate", 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
}

// ParseAskUpdate is a log parse operation binding the contract event 0x492437c0ade072acdf12e63a19d8df68bb5e414e2098dc470239df87702343ea.
//
// Solidity: event AskUpdate(address indexed collection, address indexed seller, uint256 indexed tokenId, uint256 askPrice)
func (_NftMarket *NftMarketFilterer) ParseAskUpdate(log types.Log) (*NftMarketAskUpdate, error) {
	event := new(NftMarketAskUpdate)
	if err := _NftMarket.contract.UnpackLog(event, "AskUpdate", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}

// NftMarketCollectionCloseIterator is returned from FilterCollectionClose and is used to iterate over the raw logs and unpacked data for CollectionClose events raised by the NftMarket contract.
type NftMarketCollectionCloseIterator struct {
	Event *NftMarketCollectionClose // 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 *NftMarketCollectionCloseIterator) 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(NftMarketCollectionClose)
			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(NftMarketCollectionClose)
		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 *NftMarketCollectionCloseIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *NftMarketCollectionCloseIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// NftMarketCollectionClose represents a CollectionClose event raised by the NftMarket contract.
type NftMarketCollectionClose struct {
	Collection common.Address
	Raw        types.Log // Blockchain specific contextual infos
}

// FilterCollectionClose is a free log retrieval operation binding the contract event 0xf6df65a3d7d931af345d93f0420a22e8910de36c0d027c1d1ac93d5be509f5a9.
//
// Solidity: event CollectionClose(address indexed collection)
func (_NftMarket *NftMarketFilterer) FilterCollectionClose(opts *bind.FilterOpts, collection []common.Address) (*NftMarketCollectionCloseIterator, error) {

	var collectionRule []interface{}
	for _, collectionItem := range collection {
		collectionRule = append(collectionRule, collectionItem)
	}

	logs, sub, err := _NftMarket.contract.FilterLogs(opts, "CollectionClose", collectionRule)
	if err != nil {
		return nil, err
	}
	return &NftMarketCollectionCloseIterator{contract: _NftMarket.contract, event: "CollectionClose", logs: logs, sub: sub}, nil
}

// WatchCollectionClose is a free log subscription operation binding the contract event 0xf6df65a3d7d931af345d93f0420a22e8910de36c0d027c1d1ac93d5be509f5a9.
//
// Solidity: event CollectionClose(address indexed collection)
func (_NftMarket *NftMarketFilterer) WatchCollectionClose(opts *bind.WatchOpts, sink chan<- *NftMarketCollectionClose, collection []common.Address) (event.Subscription, error) {

	var collectionRule []interface{}
	for _, collectionItem := range collection {
		collectionRule = append(collectionRule, collectionItem)
	}

	logs, sub, err := _NftMarket.contract.WatchLogs(opts, "CollectionClose", collectionRule)
	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(NftMarketCollectionClose)
				if err := _NftMarket.contract.UnpackLog(event, "CollectionClose", 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
}

// ParseCollectionClose is a log parse operation binding the contract event 0xf6df65a3d7d931af345d93f0420a22e8910de36c0d027c1d1ac93d5be509f5a9.
//
// Solidity: event CollectionClose(address indexed collection)
func (_NftMarket *NftMarketFilterer) ParseCollectionClose(log types.Log) (*NftMarketCollectionClose, error) {
	event := new(NftMarketCollectionClose)
	if err := _NftMarket.contract.UnpackLog(event, "CollectionClose", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}

// NftMarketCollectionNewIterator is returned from FilterCollectionNew and is used to iterate over the raw logs and unpacked data for CollectionNew events raised by the NftMarket contract.
type NftMarketCollectionNewIterator struct {
	Event *NftMarketCollectionNew // 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 *NftMarketCollectionNewIterator) 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(NftMarketCollectionNew)
			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(NftMarketCollectionNew)
		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 *NftMarketCollectionNewIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *NftMarketCollectionNewIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// NftMarketCollectionNew represents a CollectionNew event raised by the NftMarket contract.
type NftMarketCollectionNew struct {
	Collection       common.Address
	Creator          common.Address
	WhitelistChecker common.Address
	TradingFee       *big.Int
	CreatorFee       *big.Int
	Raw              types.Log // Blockchain specific contextual infos
}

// FilterCollectionNew is a free log retrieval operation binding the contract event 0x4863c75720ebabd11e0cf1c60b58786b5572680a20fa1b568c203964ae56026a.
//
// Solidity: event CollectionNew(address indexed collection, address indexed creator, address indexed whitelistChecker, uint256 tradingFee, uint256 creatorFee)
func (_NftMarket *NftMarketFilterer) FilterCollectionNew(opts *bind.FilterOpts, collection []common.Address, creator []common.Address, whitelistChecker []common.Address) (*NftMarketCollectionNewIterator, error) {

	var collectionRule []interface{}
	for _, collectionItem := range collection {
		collectionRule = append(collectionRule, collectionItem)
	}
	var creatorRule []interface{}
	for _, creatorItem := range creator {
		creatorRule = append(creatorRule, creatorItem)
	}
	var whitelistCheckerRule []interface{}
	for _, whitelistCheckerItem := range whitelistChecker {
		whitelistCheckerRule = append(whitelistCheckerRule, whitelistCheckerItem)
	}

	logs, sub, err := _NftMarket.contract.FilterLogs(opts, "CollectionNew", collectionRule, creatorRule, whitelistCheckerRule)
	if err != nil {
		return nil, err
	}
	return &NftMarketCollectionNewIterator{contract: _NftMarket.contract, event: "CollectionNew", logs: logs, sub: sub}, nil
}

// WatchCollectionNew is a free log subscription operation binding the contract event 0x4863c75720ebabd11e0cf1c60b58786b5572680a20fa1b568c203964ae56026a.
//
// Solidity: event CollectionNew(address indexed collection, address indexed creator, address indexed whitelistChecker, uint256 tradingFee, uint256 creatorFee)
func (_NftMarket *NftMarketFilterer) WatchCollectionNew(opts *bind.WatchOpts, sink chan<- *NftMarketCollectionNew, collection []common.Address, creator []common.Address, whitelistChecker []common.Address) (event.Subscription, error) {

	var collectionRule []interface{}
	for _, collectionItem := range collection {
		collectionRule = append(collectionRule, collectionItem)
	}
	var creatorRule []interface{}
	for _, creatorItem := range creator {
		creatorRule = append(creatorRule, creatorItem)
	}
	var whitelistCheckerRule []interface{}
	for _, whitelistCheckerItem := range whitelistChecker {
		whitelistCheckerRule = append(whitelistCheckerRule, whitelistCheckerItem)
	}

	logs, sub, err := _NftMarket.contract.WatchLogs(opts, "CollectionNew", collectionRule, creatorRule, whitelistCheckerRule)
	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(NftMarketCollectionNew)
				if err := _NftMarket.contract.UnpackLog(event, "CollectionNew", 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
}

// ParseCollectionNew is a log parse operation binding the contract event 0x4863c75720ebabd11e0cf1c60b58786b5572680a20fa1b568c203964ae56026a.
//
// Solidity: event CollectionNew(address indexed collection, address indexed creator, address indexed whitelistChecker, uint256 tradingFee, uint256 creatorFee)
func (_NftMarket *NftMarketFilterer) ParseCollectionNew(log types.Log) (*NftMarketCollectionNew, error) {
	event := new(NftMarketCollectionNew)
	if err := _NftMarket.contract.UnpackLog(event, "CollectionNew", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}

// NftMarketCollectionUpdateIterator is returned from FilterCollectionUpdate and is used to iterate over the raw logs and unpacked data for CollectionUpdate events raised by the NftMarket contract.
type NftMarketCollectionUpdateIterator struct {
	Event *NftMarketCollectionUpdate // 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 *NftMarketCollectionUpdateIterator) 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(NftMarketCollectionUpdate)
			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(NftMarketCollectionUpdate)
		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 *NftMarketCollectionUpdateIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *NftMarketCollectionUpdateIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// NftMarketCollectionUpdate represents a CollectionUpdate event raised by the NftMarket contract.
type NftMarketCollectionUpdate struct {
	Collection       common.Address
	Creator          common.Address
	WhitelistChecker common.Address
	TradingFee       *big.Int
	CreatorFee       *big.Int
	Raw              types.Log // Blockchain specific contextual infos
}

// FilterCollectionUpdate is a free log retrieval operation binding the contract event 0x655bd8b9d972737b566ec5473b537d81d079c6e251d4986005bf3f36000eacef.
//
// Solidity: event CollectionUpdate(address indexed collection, address indexed creator, address indexed whitelistChecker, uint256 tradingFee, uint256 creatorFee)
func (_NftMarket *NftMarketFilterer) FilterCollectionUpdate(opts *bind.FilterOpts, collection []common.Address, creator []common.Address, whitelistChecker []common.Address) (*NftMarketCollectionUpdateIterator, error) {

	var collectionRule []interface{}
	for _, collectionItem := range collection {
		collectionRule = append(collectionRule, collectionItem)
	}
	var creatorRule []interface{}
	for _, creatorItem := range creator {
		creatorRule = append(creatorRule, creatorItem)
	}
	var whitelistCheckerRule []interface{}
	for _, whitelistCheckerItem := range whitelistChecker {
		whitelistCheckerRule = append(whitelistCheckerRule, whitelistCheckerItem)
	}

	logs, sub, err := _NftMarket.contract.FilterLogs(opts, "CollectionUpdate", collectionRule, creatorRule, whitelistCheckerRule)
	if err != nil {
		return nil, err
	}
	return &NftMarketCollectionUpdateIterator{contract: _NftMarket.contract, event: "CollectionUpdate", logs: logs, sub: sub}, nil
}

// WatchCollectionUpdate is a free log subscription operation binding the contract event 0x655bd8b9d972737b566ec5473b537d81d079c6e251d4986005bf3f36000eacef.
//
// Solidity: event CollectionUpdate(address indexed collection, address indexed creator, address indexed whitelistChecker, uint256 tradingFee, uint256 creatorFee)
func (_NftMarket *NftMarketFilterer) WatchCollectionUpdate(opts *bind.WatchOpts, sink chan<- *NftMarketCollectionUpdate, collection []common.Address, creator []common.Address, whitelistChecker []common.Address) (event.Subscription, error) {

	var collectionRule []interface{}
	for _, collectionItem := range collection {
		collectionRule = append(collectionRule, collectionItem)
	}
	var creatorRule []interface{}
	for _, creatorItem := range creator {
		creatorRule = append(creatorRule, creatorItem)
	}
	var whitelistCheckerRule []interface{}
	for _, whitelistCheckerItem := range whitelistChecker {
		whitelistCheckerRule = append(whitelistCheckerRule, whitelistCheckerItem)
	}

	logs, sub, err := _NftMarket.contract.WatchLogs(opts, "CollectionUpdate", collectionRule, creatorRule, whitelistCheckerRule)
	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(NftMarketCollectionUpdate)
				if err := _NftMarket.contract.UnpackLog(event, "CollectionUpdate", 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
}

// ParseCollectionUpdate is a log parse operation binding the contract event 0x655bd8b9d972737b566ec5473b537d81d079c6e251d4986005bf3f36000eacef.
//
// Solidity: event CollectionUpdate(address indexed collection, address indexed creator, address indexed whitelistChecker, uint256 tradingFee, uint256 creatorFee)
func (_NftMarket *NftMarketFilterer) ParseCollectionUpdate(log types.Log) (*NftMarketCollectionUpdate, error) {
	event := new(NftMarketCollectionUpdate)
	if err := _NftMarket.contract.UnpackLog(event, "CollectionUpdate", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}

// NftMarketNewAdminAndTreasuryAddressesIterator is returned from FilterNewAdminAndTreasuryAddresses and is used to iterate over the raw logs and unpacked data for NewAdminAndTreasuryAddresses events raised by the NftMarket contract.
type NftMarketNewAdminAndTreasuryAddressesIterator struct {
	Event *NftMarketNewAdminAndTreasuryAddresses // 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 *NftMarketNewAdminAndTreasuryAddressesIterator) 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(NftMarketNewAdminAndTreasuryAddresses)
			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(NftMarketNewAdminAndTreasuryAddresses)
		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 *NftMarketNewAdminAndTreasuryAddressesIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *NftMarketNewAdminAndTreasuryAddressesIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// NftMarketNewAdminAndTreasuryAddresses represents a NewAdminAndTreasuryAddresses event raised by the NftMarket contract.
type NftMarketNewAdminAndTreasuryAddresses struct {
	Admin    common.Address
	Treasury common.Address
	Raw      types.Log // Blockchain specific contextual infos
}

// FilterNewAdminAndTreasuryAddresses is a free log retrieval operation binding the contract event 0x2a1b1d9b1cb634e511bbf940f66e95082249486cf37efdb4bccba1c5f4c00b9b.
//
// Solidity: event NewAdminAndTreasuryAddresses(address indexed admin, address indexed treasury)
func (_NftMarket *NftMarketFilterer) FilterNewAdminAndTreasuryAddresses(opts *bind.FilterOpts, admin []common.Address, treasury []common.Address) (*NftMarketNewAdminAndTreasuryAddressesIterator, error) {

	var adminRule []interface{}
	for _, adminItem := range admin {
		adminRule = append(adminRule, adminItem)
	}
	var treasuryRule []interface{}
	for _, treasuryItem := range treasury {
		treasuryRule = append(treasuryRule, treasuryItem)
	}

	logs, sub, err := _NftMarket.contract.FilterLogs(opts, "NewAdminAndTreasuryAddresses", adminRule, treasuryRule)
	if err != nil {
		return nil, err
	}
	return &NftMarketNewAdminAndTreasuryAddressesIterator{contract: _NftMarket.contract, event: "NewAdminAndTreasuryAddresses", logs: logs, sub: sub}, nil
}

// WatchNewAdminAndTreasuryAddresses is a free log subscription operation binding the contract event 0x2a1b1d9b1cb634e511bbf940f66e95082249486cf37efdb4bccba1c5f4c00b9b.
//
// Solidity: event NewAdminAndTreasuryAddresses(address indexed admin, address indexed treasury)
func (_NftMarket *NftMarketFilterer) WatchNewAdminAndTreasuryAddresses(opts *bind.WatchOpts, sink chan<- *NftMarketNewAdminAndTreasuryAddresses, admin []common.Address, treasury []common.Address) (event.Subscription, error) {

	var adminRule []interface{}
	for _, adminItem := range admin {
		adminRule = append(adminRule, adminItem)
	}
	var treasuryRule []interface{}
	for _, treasuryItem := range treasury {
		treasuryRule = append(treasuryRule, treasuryItem)
	}

	logs, sub, err := _NftMarket.contract.WatchLogs(opts, "NewAdminAndTreasuryAddresses", adminRule, treasuryRule)
	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(NftMarketNewAdminAndTreasuryAddresses)
				if err := _NftMarket.contract.UnpackLog(event, "NewAdminAndTreasuryAddresses", 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
}

// ParseNewAdminAndTreasuryAddresses is a log parse operation binding the contract event 0x2a1b1d9b1cb634e511bbf940f66e95082249486cf37efdb4bccba1c5f4c00b9b.
//
// Solidity: event NewAdminAndTreasuryAddresses(address indexed admin, address indexed treasury)
func (_NftMarket *NftMarketFilterer) ParseNewAdminAndTreasuryAddresses(log types.Log) (*NftMarketNewAdminAndTreasuryAddresses, error) {
	event := new(NftMarketNewAdminAndTreasuryAddresses)
	if err := _NftMarket.contract.UnpackLog(event, "NewAdminAndTreasuryAddresses", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}

// NftMarketNewMinimumAndMaximumAskPricesIterator is returned from FilterNewMinimumAndMaximumAskPrices and is used to iterate over the raw logs and unpacked data for NewMinimumAndMaximumAskPrices events raised by the NftMarket contract.
type NftMarketNewMinimumAndMaximumAskPricesIterator struct {
	Event *NftMarketNewMinimumAndMaximumAskPrices // 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 *NftMarketNewMinimumAndMaximumAskPricesIterator) 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(NftMarketNewMinimumAndMaximumAskPrices)
			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(NftMarketNewMinimumAndMaximumAskPrices)
		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 *NftMarketNewMinimumAndMaximumAskPricesIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *NftMarketNewMinimumAndMaximumAskPricesIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// NftMarketNewMinimumAndMaximumAskPrices represents a NewMinimumAndMaximumAskPrices event raised by the NftMarket contract.
type NftMarketNewMinimumAndMaximumAskPrices struct {
	MinimumAskPrice *big.Int
	MaximumAskPrice *big.Int
	Raw             types.Log // Blockchain specific contextual infos
}

// FilterNewMinimumAndMaximumAskPrices is a free log retrieval operation binding the contract event 0xb25b7c478b617cc7fb07f97a49dc7dcba200dae3abbcb0aa17216e2ae6deaef7.
//
// Solidity: event NewMinimumAndMaximumAskPrices(uint256 minimumAskPrice, uint256 maximumAskPrice)
func (_NftMarket *NftMarketFilterer) FilterNewMinimumAndMaximumAskPrices(opts *bind.FilterOpts) (*NftMarketNewMinimumAndMaximumAskPricesIterator, error) {

	logs, sub, err := _NftMarket.contract.FilterLogs(opts, "NewMinimumAndMaximumAskPrices")
	if err != nil {
		return nil, err
	}
	return &NftMarketNewMinimumAndMaximumAskPricesIterator{contract: _NftMarket.contract, event: "NewMinimumAndMaximumAskPrices", logs: logs, sub: sub}, nil
}

// WatchNewMinimumAndMaximumAskPrices is a free log subscription operation binding the contract event 0xb25b7c478b617cc7fb07f97a49dc7dcba200dae3abbcb0aa17216e2ae6deaef7.
//
// Solidity: event NewMinimumAndMaximumAskPrices(uint256 minimumAskPrice, uint256 maximumAskPrice)
func (_NftMarket *NftMarketFilterer) WatchNewMinimumAndMaximumAskPrices(opts *bind.WatchOpts, sink chan<- *NftMarketNewMinimumAndMaximumAskPrices) (event.Subscription, error) {

	logs, sub, err := _NftMarket.contract.WatchLogs(opts, "NewMinimumAndMaximumAskPrices")
	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(NftMarketNewMinimumAndMaximumAskPrices)
				if err := _NftMarket.contract.UnpackLog(event, "NewMinimumAndMaximumAskPrices", 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
}

// ParseNewMinimumAndMaximumAskPrices is a log parse operation binding the contract event 0xb25b7c478b617cc7fb07f97a49dc7dcba200dae3abbcb0aa17216e2ae6deaef7.
//
// Solidity: event NewMinimumAndMaximumAskPrices(uint256 minimumAskPrice, uint256 maximumAskPrice)
func (_NftMarket *NftMarketFilterer) ParseNewMinimumAndMaximumAskPrices(log types.Log) (*NftMarketNewMinimumAndMaximumAskPrices, error) {
	event := new(NftMarketNewMinimumAndMaximumAskPrices)
	if err := _NftMarket.contract.UnpackLog(event, "NewMinimumAndMaximumAskPrices", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}

// NftMarketNonFungibleTokenRecoveryIterator is returned from FilterNonFungibleTokenRecovery and is used to iterate over the raw logs and unpacked data for NonFungibleTokenRecovery events raised by the NftMarket contract.
type NftMarketNonFungibleTokenRecoveryIterator struct {
	Event *NftMarketNonFungibleTokenRecovery // 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 *NftMarketNonFungibleTokenRecoveryIterator) 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(NftMarketNonFungibleTokenRecovery)
			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(NftMarketNonFungibleTokenRecovery)
		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 *NftMarketNonFungibleTokenRecoveryIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *NftMarketNonFungibleTokenRecoveryIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// NftMarketNonFungibleTokenRecovery represents a NonFungibleTokenRecovery event raised by the NftMarket contract.
type NftMarketNonFungibleTokenRecovery struct {
	Token   common.Address
	TokenId *big.Int
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterNonFungibleTokenRecovery is a free log retrieval operation binding the contract event 0x861c3ea25dbda3af0bf5d258ba8582c0276c9446b1479e817be3f1b4a89acf91.
//
// Solidity: event NonFungibleTokenRecovery(address indexed token, uint256 indexed tokenId)
func (_NftMarket *NftMarketFilterer) FilterNonFungibleTokenRecovery(opts *bind.FilterOpts, token []common.Address, tokenId []*big.Int) (*NftMarketNonFungibleTokenRecoveryIterator, error) {

	var tokenRule []interface{}
	for _, tokenItem := range token {
		tokenRule = append(tokenRule, tokenItem)
	}
	var tokenIdRule []interface{}
	for _, tokenIdItem := range tokenId {
		tokenIdRule = append(tokenIdRule, tokenIdItem)
	}

	logs, sub, err := _NftMarket.contract.FilterLogs(opts, "NonFungibleTokenRecovery", tokenRule, tokenIdRule)
	if err != nil {
		return nil, err
	}
	return &NftMarketNonFungibleTokenRecoveryIterator{contract: _NftMarket.contract, event: "NonFungibleTokenRecovery", logs: logs, sub: sub}, nil
}

// WatchNonFungibleTokenRecovery is a free log subscription operation binding the contract event 0x861c3ea25dbda3af0bf5d258ba8582c0276c9446b1479e817be3f1b4a89acf91.
//
// Solidity: event NonFungibleTokenRecovery(address indexed token, uint256 indexed tokenId)
func (_NftMarket *NftMarketFilterer) WatchNonFungibleTokenRecovery(opts *bind.WatchOpts, sink chan<- *NftMarketNonFungibleTokenRecovery, token []common.Address, tokenId []*big.Int) (event.Subscription, error) {

	var tokenRule []interface{}
	for _, tokenItem := range token {
		tokenRule = append(tokenRule, tokenItem)
	}
	var tokenIdRule []interface{}
	for _, tokenIdItem := range tokenId {
		tokenIdRule = append(tokenIdRule, tokenIdItem)
	}

	logs, sub, err := _NftMarket.contract.WatchLogs(opts, "NonFungibleTokenRecovery", tokenRule, 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(NftMarketNonFungibleTokenRecovery)
				if err := _NftMarket.contract.UnpackLog(event, "NonFungibleTokenRecovery", 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
}

// ParseNonFungibleTokenRecovery is a log parse operation binding the contract event 0x861c3ea25dbda3af0bf5d258ba8582c0276c9446b1479e817be3f1b4a89acf91.
//
// Solidity: event NonFungibleTokenRecovery(address indexed token, uint256 indexed tokenId)
func (_NftMarket *NftMarketFilterer) ParseNonFungibleTokenRecovery(log types.Log) (*NftMarketNonFungibleTokenRecovery, error) {
	event := new(NftMarketNonFungibleTokenRecovery)
	if err := _NftMarket.contract.UnpackLog(event, "NonFungibleTokenRecovery", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}

// NftMarketOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the NftMarket contract.
type NftMarketOwnershipTransferredIterator struct {
	Event *NftMarketOwnershipTransferred // 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 *NftMarketOwnershipTransferredIterator) 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(NftMarketOwnershipTransferred)
			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(NftMarketOwnershipTransferred)
		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 *NftMarketOwnershipTransferredIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *NftMarketOwnershipTransferredIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// NftMarketOwnershipTransferred represents a OwnershipTransferred event raised by the NftMarket contract.
type NftMarketOwnershipTransferred struct {
	PreviousOwner common.Address
	NewOwner      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_NftMarket *NftMarketFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*NftMarketOwnershipTransferredIterator, error) {

	var previousOwnerRule []interface{}
	for _, previousOwnerItem := range previousOwner {
		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
	}
	var newOwnerRule []interface{}
	for _, newOwnerItem := range newOwner {
		newOwnerRule = append(newOwnerRule, newOwnerItem)
	}

	logs, sub, err := _NftMarket.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
	if err != nil {
		return nil, err
	}
	return &NftMarketOwnershipTransferredIterator{contract: _NftMarket.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
}

// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_NftMarket *NftMarketFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *NftMarketOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {

	var previousOwnerRule []interface{}
	for _, previousOwnerItem := range previousOwner {
		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
	}
	var newOwnerRule []interface{}
	for _, newOwnerItem := range newOwner {
		newOwnerRule = append(newOwnerRule, newOwnerItem)
	}

	logs, sub, err := _NftMarket.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
	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(NftMarketOwnershipTransferred)
				if err := _NftMarket.contract.UnpackLog(event, "OwnershipTransferred", 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
}

// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
//
// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
func (_NftMarket *NftMarketFilterer) ParseOwnershipTransferred(log types.Log) (*NftMarketOwnershipTransferred, error) {
	event := new(NftMarketOwnershipTransferred)
	if err := _NftMarket.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}

// NftMarketRevenueClaimIterator is returned from FilterRevenueClaim and is used to iterate over the raw logs and unpacked data for RevenueClaim events raised by the NftMarket contract.
type NftMarketRevenueClaimIterator struct {
	Event *NftMarketRevenueClaim // 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 *NftMarketRevenueClaimIterator) 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(NftMarketRevenueClaim)
			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(NftMarketRevenueClaim)
		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 *NftMarketRevenueClaimIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *NftMarketRevenueClaimIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// NftMarketRevenueClaim represents a RevenueClaim event raised by the NftMarket contract.
type NftMarketRevenueClaim struct {
	Claimer common.Address
	Amount  *big.Int
	Raw     types.Log // Blockchain specific contextual infos
}

// FilterRevenueClaim is a free log retrieval operation binding the contract event 0xc6cb6f1a9d5212d4ee3819d9b175a85e8333a7327d53dfbc1b610e1fd8ec3cb5.
//
// Solidity: event RevenueClaim(address indexed claimer, uint256 amount)
func (_NftMarket *NftMarketFilterer) FilterRevenueClaim(opts *bind.FilterOpts, claimer []common.Address) (*NftMarketRevenueClaimIterator, error) {

	var claimerRule []interface{}
	for _, claimerItem := range claimer {
		claimerRule = append(claimerRule, claimerItem)
	}

	logs, sub, err := _NftMarket.contract.FilterLogs(opts, "RevenueClaim", claimerRule)
	if err != nil {
		return nil, err
	}
	return &NftMarketRevenueClaimIterator{contract: _NftMarket.contract, event: "RevenueClaim", logs: logs, sub: sub}, nil
}

// WatchRevenueClaim is a free log subscription operation binding the contract event 0xc6cb6f1a9d5212d4ee3819d9b175a85e8333a7327d53dfbc1b610e1fd8ec3cb5.
//
// Solidity: event RevenueClaim(address indexed claimer, uint256 amount)
func (_NftMarket *NftMarketFilterer) WatchRevenueClaim(opts *bind.WatchOpts, sink chan<- *NftMarketRevenueClaim, claimer []common.Address) (event.Subscription, error) {

	var claimerRule []interface{}
	for _, claimerItem := range claimer {
		claimerRule = append(claimerRule, claimerItem)
	}

	logs, sub, err := _NftMarket.contract.WatchLogs(opts, "RevenueClaim", claimerRule)
	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(NftMarketRevenueClaim)
				if err := _NftMarket.contract.UnpackLog(event, "RevenueClaim", 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
}

// ParseRevenueClaim is a log parse operation binding the contract event 0xc6cb6f1a9d5212d4ee3819d9b175a85e8333a7327d53dfbc1b610e1fd8ec3cb5.
//
// Solidity: event RevenueClaim(address indexed claimer, uint256 amount)
func (_NftMarket *NftMarketFilterer) ParseRevenueClaim(log types.Log) (*NftMarketRevenueClaim, error) {
	event := new(NftMarketRevenueClaim)
	if err := _NftMarket.contract.UnpackLog(event, "RevenueClaim", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}

// NftMarketTokenRecoveryIterator is returned from FilterTokenRecovery and is used to iterate over the raw logs and unpacked data for TokenRecovery events raised by the NftMarket contract.
type NftMarketTokenRecoveryIterator struct {
	Event *NftMarketTokenRecovery // 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 *NftMarketTokenRecoveryIterator) 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(NftMarketTokenRecovery)
			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(NftMarketTokenRecovery)
		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 *NftMarketTokenRecoveryIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *NftMarketTokenRecoveryIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// NftMarketTokenRecovery represents a TokenRecovery event raised by the NftMarket contract.
type NftMarketTokenRecovery struct {
	Token  common.Address
	Amount *big.Int
	Raw    types.Log // Blockchain specific contextual infos
}

// FilterTokenRecovery is a free log retrieval operation binding the contract event 0x14f11966a996e0629572e51064726d2057a80fbd34efc066682c06a71dbb6e98.
//
// Solidity: event TokenRecovery(address indexed token, uint256 amount)
func (_NftMarket *NftMarketFilterer) FilterTokenRecovery(opts *bind.FilterOpts, token []common.Address) (*NftMarketTokenRecoveryIterator, error) {

	var tokenRule []interface{}
	for _, tokenItem := range token {
		tokenRule = append(tokenRule, tokenItem)
	}

	logs, sub, err := _NftMarket.contract.FilterLogs(opts, "TokenRecovery", tokenRule)
	if err != nil {
		return nil, err
	}
	return &NftMarketTokenRecoveryIterator{contract: _NftMarket.contract, event: "TokenRecovery", logs: logs, sub: sub}, nil
}

// WatchTokenRecovery is a free log subscription operation binding the contract event 0x14f11966a996e0629572e51064726d2057a80fbd34efc066682c06a71dbb6e98.
//
// Solidity: event TokenRecovery(address indexed token, uint256 amount)
func (_NftMarket *NftMarketFilterer) WatchTokenRecovery(opts *bind.WatchOpts, sink chan<- *NftMarketTokenRecovery, token []common.Address) (event.Subscription, error) {

	var tokenRule []interface{}
	for _, tokenItem := range token {
		tokenRule = append(tokenRule, tokenItem)
	}

	logs, sub, err := _NftMarket.contract.WatchLogs(opts, "TokenRecovery", tokenRule)
	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(NftMarketTokenRecovery)
				if err := _NftMarket.contract.UnpackLog(event, "TokenRecovery", 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
}

// ParseTokenRecovery is a log parse operation binding the contract event 0x14f11966a996e0629572e51064726d2057a80fbd34efc066682c06a71dbb6e98.
//
// Solidity: event TokenRecovery(address indexed token, uint256 amount)
func (_NftMarket *NftMarketFilterer) ParseTokenRecovery(log types.Log) (*NftMarketTokenRecovery, error) {
	event := new(NftMarketTokenRecovery)
	if err := _NftMarket.contract.UnpackLog(event, "TokenRecovery", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}

// NftMarketTradeIterator is returned from FilterTrade and is used to iterate over the raw logs and unpacked data for Trade events raised by the NftMarket contract.
type NftMarketTradeIterator struct {
	Event *NftMarketTrade // 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 *NftMarketTradeIterator) 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(NftMarketTrade)
			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(NftMarketTrade)
		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 *NftMarketTradeIterator) Error() error {
	return it.fail
}

// Close terminates the iteration process, releasing any pending underlying
// resources.
func (it *NftMarketTradeIterator) Close() error {
	it.sub.Unsubscribe()
	return nil
}

// NftMarketTrade represents a Trade event raised by the NftMarket contract.
type NftMarketTrade struct {
	Collection common.Address
	TokenId    *big.Int
	Seller     common.Address
	Buyer      common.Address
	AskPrice   *big.Int
	NetPrice   *big.Int
	WithBNB    bool
	Raw        types.Log // Blockchain specific contextual infos
}

// FilterTrade is a free log retrieval operation binding the contract event 0xdaac0e40b8f01e970d08d4e8ae57ac31a5845fffde104c43f05e19bbec78491e.
//
// Solidity: event Trade(address indexed collection, uint256 indexed tokenId, address indexed seller, address buyer, uint256 askPrice, uint256 netPrice, bool withBNB)
func (_NftMarket *NftMarketFilterer) FilterTrade(opts *bind.FilterOpts, collection []common.Address, tokenId []*big.Int, seller []common.Address) (*NftMarketTradeIterator, error) {

	var collectionRule []interface{}
	for _, collectionItem := range collection {
		collectionRule = append(collectionRule, collectionItem)
	}
	var tokenIdRule []interface{}
	for _, tokenIdItem := range tokenId {
		tokenIdRule = append(tokenIdRule, tokenIdItem)
	}
	var sellerRule []interface{}
	for _, sellerItem := range seller {
		sellerRule = append(sellerRule, sellerItem)
	}

	logs, sub, err := _NftMarket.contract.FilterLogs(opts, "Trade", collectionRule, tokenIdRule, sellerRule)
	if err != nil {
		return nil, err
	}
	return &NftMarketTradeIterator{contract: _NftMarket.contract, event: "Trade", logs: logs, sub: sub}, nil
}

// WatchTrade is a free log subscription operation binding the contract event 0xdaac0e40b8f01e970d08d4e8ae57ac31a5845fffde104c43f05e19bbec78491e.
//
// Solidity: event Trade(address indexed collection, uint256 indexed tokenId, address indexed seller, address buyer, uint256 askPrice, uint256 netPrice, bool withBNB)
func (_NftMarket *NftMarketFilterer) WatchTrade(opts *bind.WatchOpts, sink chan<- *NftMarketTrade, collection []common.Address, tokenId []*big.Int, seller []common.Address) (event.Subscription, error) {

	var collectionRule []interface{}
	for _, collectionItem := range collection {
		collectionRule = append(collectionRule, collectionItem)
	}
	var tokenIdRule []interface{}
	for _, tokenIdItem := range tokenId {
		tokenIdRule = append(tokenIdRule, tokenIdItem)
	}
	var sellerRule []interface{}
	for _, sellerItem := range seller {
		sellerRule = append(sellerRule, sellerItem)
	}

	logs, sub, err := _NftMarket.contract.WatchLogs(opts, "Trade", collectionRule, tokenIdRule, sellerRule)
	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(NftMarketTrade)
				if err := _NftMarket.contract.UnpackLog(event, "Trade", 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
}

// ParseTrade is a log parse operation binding the contract event 0xdaac0e40b8f01e970d08d4e8ae57ac31a5845fffde104c43f05e19bbec78491e.
//
// Solidity: event Trade(address indexed collection, uint256 indexed tokenId, address indexed seller, address buyer, uint256 askPrice, uint256 netPrice, bool withBNB)
func (_NftMarket *NftMarketFilterer) ParseTrade(log types.Log) (*NftMarketTrade, error) {
	event := new(NftMarketTrade)
	if err := _NftMarket.contract.UnpackLog(event, "Trade", log); err != nil {
		return nil, err
	}
	event.Raw = log
	return event, nil
}