evm/pancakeswap/contracts/nftmarket.go

3015 lines
134 KiB
Go
Raw Normal View History

2021-11-08 18:20:31 +00:00
// Code generated - DO NOT EDIT.
// This file is a generated binding and any manual changes will be lost.
package contracts
import (
"errors"
"math/big"
"strings"
ethereum "github.com/ethereum/go-ethereum"
"github.com/ethereum/go-ethereum/accounts/abi"
"github.com/ethereum/go-ethereum/accounts/abi/bind"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/event"
)
// Reference imports to suppress errors if they are not otherwise used.
var (
_ = errors.New
_ = big.NewInt
_ = strings.NewReader
_ = ethereum.NotFound
_ = bind.Bind
_ = common.Big1
_ = types.BloomLookup
_ = event.NewSubscription
)
// 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
}