github.com/diadata-org/diadata@v1.4.593/config/nftContracts/cryptopunk/cryptopunk.go (about) 1 // Code generated - DO NOT EDIT. 2 // This file is a generated binding and any manual changes will be lost. 3 4 package cryptopunk 5 6 import ( 7 "math/big" 8 "strings" 9 10 ethereum "github.com/ethereum/go-ethereum" 11 "github.com/ethereum/go-ethereum/accounts/abi" 12 "github.com/ethereum/go-ethereum/accounts/abi/bind" 13 "github.com/ethereum/go-ethereum/common" 14 "github.com/ethereum/go-ethereum/core/types" 15 "github.com/ethereum/go-ethereum/event" 16 ) 17 18 // Reference imports to suppress errors if they are not otherwise used. 19 var ( 20 _ = big.NewInt 21 _ = strings.NewReader 22 _ = ethereum.NotFound 23 _ = bind.Bind 24 _ = common.Big1 25 _ = types.BloomLookup 26 _ = event.NewSubscription 27 ) 28 29 // CryptoPunksMarketABI is the input ABI used to generate the binding from. 30 const CryptoPunksMarketABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"punksOfferedForSale\",\"outputs\":[{\"name\":\"isForSale\",\"type\":\"bool\"},{\"name\":\"punkIndex\",\"type\":\"uint256\"},{\"name\":\"seller\",\"type\":\"address\"},{\"name\":\"minValue\",\"type\":\"uint256\"},{\"name\":\"onlySellTo\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"punkIndex\",\"type\":\"uint256\"}],\"name\":\"enterBidForPunk\",\"outputs\":[],\"payable\":true,\"stateMutability\":\"payable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"punkIndex\",\"type\":\"uint256\"},{\"name\":\"minPrice\",\"type\":\"uint256\"}],\"name\":\"acceptBidForPunk\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"addresses\",\"type\":\"address[]\"},{\"name\":\"indices\",\"type\":\"uint256[]\"}],\"name\":\"setInitialOwners\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"withdraw\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"imageHash\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"nextPunkIndexToAssign\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"punkIndexToAddress\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"standard\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"punkBids\",\"outputs\":[{\"name\":\"hasBid\",\"type\":\"bool\"},{\"name\":\"punkIndex\",\"type\":\"uint256\"},{\"name\":\"bidder\",\"type\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"allInitialOwnersAssigned\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"allPunksAssigned\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"punkIndex\",\"type\":\"uint256\"}],\"name\":\"buyPunk\",\"outputs\":[],\"payable\":true,\"stateMutability\":\"payable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"punkIndex\",\"type\":\"uint256\"}],\"name\":\"transferPunk\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"punkIndex\",\"type\":\"uint256\"}],\"name\":\"withdrawBidForPunk\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"punkIndex\",\"type\":\"uint256\"}],\"name\":\"setInitialOwner\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"punkIndex\",\"type\":\"uint256\"},{\"name\":\"minSalePriceInWei\",\"type\":\"uint256\"},{\"name\":\"toAddress\",\"type\":\"address\"}],\"name\":\"offerPunkForSaleToAddress\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"punksRemainingToAssign\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"punkIndex\",\"type\":\"uint256\"},{\"name\":\"minSalePriceInWei\",\"type\":\"uint256\"}],\"name\":\"offerPunkForSale\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"punkIndex\",\"type\":\"uint256\"}],\"name\":\"getPunk\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"}],\"name\":\"pendingWithdrawals\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"punkIndex\",\"type\":\"uint256\"}],\"name\":\"punkNoLongerForSale\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"payable\":true,\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"punkIndex\",\"type\":\"uint256\"}],\"name\":\"Assign\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"punkIndex\",\"type\":\"uint256\"}],\"name\":\"PunkTransfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"punkIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"minValue\",\"type\":\"uint256\"},{\"indexed\":true,\"name\":\"toAddress\",\"type\":\"address\"}],\"name\":\"PunkOffered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"punkIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":true,\"name\":\"fromAddress\",\"type\":\"address\"}],\"name\":\"PunkBidEntered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"punkIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":true,\"name\":\"fromAddress\",\"type\":\"address\"}],\"name\":\"PunkBidWithdrawn\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"punkIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":true,\"name\":\"fromAddress\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"toAddress\",\"type\":\"address\"}],\"name\":\"PunkBought\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"punkIndex\",\"type\":\"uint256\"}],\"name\":\"PunkNoLongerForSale\",\"type\":\"event\"}]" 31 32 // CryptoPunksMarketFuncSigs maps the 4-byte function signature to its string representation. 33 var CryptoPunksMarketFuncSigs = map[string]string{ 34 "23165b75": "acceptBidForPunk(uint256,uint256)", 35 "7ecedac9": "allInitialOwnersAssigned()", 36 "8126c38a": "allPunksAssigned()", 37 "70a08231": "balanceOf(address)", 38 "8264fe98": "buyPunk(uint256)", 39 "313ce567": "decimals()", 40 "091dbfd2": "enterBidForPunk(uint256)", 41 "c81d1d5b": "getPunk(uint256)", 42 "51605d80": "imageHash()", 43 "06fdde03": "name()", 44 "52f29a25": "nextPunkIndexToAssign()", 45 "c44193c3": "offerPunkForSale(uint256,uint256)", 46 "bf31196f": "offerPunkForSaleToAddress(uint256,uint256,address)", 47 "f3f43703": "pendingWithdrawals(address)", 48 "6e743fa9": "punkBids(uint256)", 49 "58178168": "punkIndexToAddress(uint256)", 50 "f6eeff1e": "punkNoLongerForSale(uint256)", 51 "088f11f3": "punksOfferedForSale(uint256)", 52 "c0d6ce63": "punksRemainingToAssign()", 53 "a75a9049": "setInitialOwner(address,uint256)", 54 "39c5dde6": "setInitialOwners(address[],uint256[])", 55 "5a3b7e42": "standard()", 56 "95d89b41": "symbol()", 57 "18160ddd": "totalSupply()", 58 "8b72a2ec": "transferPunk(address,uint256)", 59 "3ccfd60b": "withdraw()", 60 "979bc638": "withdrawBidForPunk(uint256)", 61 } 62 63 // CryptoPunksMarketBin is the compiled bytecode used for deploying new contracts. 64 var CryptoPunksMarketBin = "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" 65 66 // DeployCryptoPunksMarket deploys a new Ethereum contract, binding an instance of CryptoPunksMarket to it. 67 func DeployCryptoPunksMarket(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *CryptoPunksMarket, error) { 68 parsed, err := abi.JSON(strings.NewReader(CryptoPunksMarketABI)) 69 if err != nil { 70 return common.Address{}, nil, nil, err 71 } 72 73 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(CryptoPunksMarketBin), backend) 74 if err != nil { 75 return common.Address{}, nil, nil, err 76 } 77 return address, tx, &CryptoPunksMarket{CryptoPunksMarketCaller: CryptoPunksMarketCaller{contract: contract}, CryptoPunksMarketTransactor: CryptoPunksMarketTransactor{contract: contract}, CryptoPunksMarketFilterer: CryptoPunksMarketFilterer{contract: contract}}, nil 78 } 79 80 // CryptoPunksMarket is an auto generated Go binding around an Ethereum contract. 81 type CryptoPunksMarket struct { 82 CryptoPunksMarketCaller // Read-only binding to the contract 83 CryptoPunksMarketTransactor // Write-only binding to the contract 84 CryptoPunksMarketFilterer // Log filterer for contract events 85 } 86 87 // CryptoPunksMarketCaller is an auto generated read-only Go binding around an Ethereum contract. 88 type CryptoPunksMarketCaller struct { 89 contract *bind.BoundContract // Generic contract wrapper for the low level calls 90 } 91 92 // CryptoPunksMarketTransactor is an auto generated write-only Go binding around an Ethereum contract. 93 type CryptoPunksMarketTransactor struct { 94 contract *bind.BoundContract // Generic contract wrapper for the low level calls 95 } 96 97 // CryptoPunksMarketFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 98 type CryptoPunksMarketFilterer struct { 99 contract *bind.BoundContract // Generic contract wrapper for the low level calls 100 } 101 102 // CryptoPunksMarketSession is an auto generated Go binding around an Ethereum contract, 103 // with pre-set call and transact options. 104 type CryptoPunksMarketSession struct { 105 Contract *CryptoPunksMarket // Generic contract binding to set the session for 106 CallOpts bind.CallOpts // Call options to use throughout this session 107 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 108 } 109 110 // CryptoPunksMarketCallerSession is an auto generated read-only Go binding around an Ethereum contract, 111 // with pre-set call options. 112 type CryptoPunksMarketCallerSession struct { 113 Contract *CryptoPunksMarketCaller // Generic contract caller binding to set the session for 114 CallOpts bind.CallOpts // Call options to use throughout this session 115 } 116 117 // CryptoPunksMarketTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 118 // with pre-set transact options. 119 type CryptoPunksMarketTransactorSession struct { 120 Contract *CryptoPunksMarketTransactor // Generic contract transactor binding to set the session for 121 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 122 } 123 124 // CryptoPunksMarketRaw is an auto generated low-level Go binding around an Ethereum contract. 125 type CryptoPunksMarketRaw struct { 126 Contract *CryptoPunksMarket // Generic contract binding to access the raw methods on 127 } 128 129 // CryptoPunksMarketCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 130 type CryptoPunksMarketCallerRaw struct { 131 Contract *CryptoPunksMarketCaller // Generic read-only contract binding to access the raw methods on 132 } 133 134 // CryptoPunksMarketTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 135 type CryptoPunksMarketTransactorRaw struct { 136 Contract *CryptoPunksMarketTransactor // Generic write-only contract binding to access the raw methods on 137 } 138 139 // NewCryptoPunksMarket creates a new instance of CryptoPunksMarket, bound to a specific deployed contract. 140 func NewCryptoPunksMarket(address common.Address, backend bind.ContractBackend) (*CryptoPunksMarket, error) { 141 contract, err := bindCryptoPunksMarket(address, backend, backend, backend) 142 if err != nil { 143 return nil, err 144 } 145 return &CryptoPunksMarket{CryptoPunksMarketCaller: CryptoPunksMarketCaller{contract: contract}, CryptoPunksMarketTransactor: CryptoPunksMarketTransactor{contract: contract}, CryptoPunksMarketFilterer: CryptoPunksMarketFilterer{contract: contract}}, nil 146 } 147 148 // NewCryptoPunksMarketCaller creates a new read-only instance of CryptoPunksMarket, bound to a specific deployed contract. 149 func NewCryptoPunksMarketCaller(address common.Address, caller bind.ContractCaller) (*CryptoPunksMarketCaller, error) { 150 contract, err := bindCryptoPunksMarket(address, caller, nil, nil) 151 if err != nil { 152 return nil, err 153 } 154 return &CryptoPunksMarketCaller{contract: contract}, nil 155 } 156 157 // NewCryptoPunksMarketTransactor creates a new write-only instance of CryptoPunksMarket, bound to a specific deployed contract. 158 func NewCryptoPunksMarketTransactor(address common.Address, transactor bind.ContractTransactor) (*CryptoPunksMarketTransactor, error) { 159 contract, err := bindCryptoPunksMarket(address, nil, transactor, nil) 160 if err != nil { 161 return nil, err 162 } 163 return &CryptoPunksMarketTransactor{contract: contract}, nil 164 } 165 166 // NewCryptoPunksMarketFilterer creates a new log filterer instance of CryptoPunksMarket, bound to a specific deployed contract. 167 func NewCryptoPunksMarketFilterer(address common.Address, filterer bind.ContractFilterer) (*CryptoPunksMarketFilterer, error) { 168 contract, err := bindCryptoPunksMarket(address, nil, nil, filterer) 169 if err != nil { 170 return nil, err 171 } 172 return &CryptoPunksMarketFilterer{contract: contract}, nil 173 } 174 175 // bindCryptoPunksMarket binds a generic wrapper to an already deployed contract. 176 func bindCryptoPunksMarket(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 177 parsed, err := abi.JSON(strings.NewReader(CryptoPunksMarketABI)) 178 if err != nil { 179 return nil, err 180 } 181 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 182 } 183 184 // Call invokes the (constant) contract method with params as input values and 185 // sets the output to result. The result type might be a single field for simple 186 // returns, a slice of interfaces for anonymous returns and a struct for named 187 // returns. 188 func (_CryptoPunksMarket *CryptoPunksMarketRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { 189 return _CryptoPunksMarket.Contract.CryptoPunksMarketCaller.contract.Call(opts, result, method, params...) 190 } 191 192 // Transfer initiates a plain transaction to move funds to the contract, calling 193 // its default method if one is available. 194 func (_CryptoPunksMarket *CryptoPunksMarketRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 195 return _CryptoPunksMarket.Contract.CryptoPunksMarketTransactor.contract.Transfer(opts) 196 } 197 198 // Transact invokes the (paid) contract method with params as input values. 199 func (_CryptoPunksMarket *CryptoPunksMarketRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 200 return _CryptoPunksMarket.Contract.CryptoPunksMarketTransactor.contract.Transact(opts, method, params...) 201 } 202 203 // Call invokes the (constant) contract method with params as input values and 204 // sets the output to result. The result type might be a single field for simple 205 // returns, a slice of interfaces for anonymous returns and a struct for named 206 // returns. 207 func (_CryptoPunksMarket *CryptoPunksMarketCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { 208 return _CryptoPunksMarket.Contract.contract.Call(opts, result, method, params...) 209 } 210 211 // Transfer initiates a plain transaction to move funds to the contract, calling 212 // its default method if one is available. 213 func (_CryptoPunksMarket *CryptoPunksMarketTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 214 return _CryptoPunksMarket.Contract.contract.Transfer(opts) 215 } 216 217 // Transact invokes the (paid) contract method with params as input values. 218 func (_CryptoPunksMarket *CryptoPunksMarketTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 219 return _CryptoPunksMarket.Contract.contract.Transact(opts, method, params...) 220 } 221 222 // AllPunksAssigned is a free data retrieval call binding the contract method 0x8126c38a. 223 // 224 // Solidity: function allPunksAssigned() view returns(bool) 225 func (_CryptoPunksMarket *CryptoPunksMarketCaller) AllPunksAssigned(opts *bind.CallOpts) (bool, error) { 226 var out []interface{} 227 err := _CryptoPunksMarket.contract.Call(opts, &out, "allPunksAssigned") 228 229 if err != nil { 230 return *new(bool), err 231 } 232 233 out0 := *abi.ConvertType(out[0], new(bool)).(*bool) 234 235 return out0, err 236 237 } 238 239 // AllPunksAssigned is a free data retrieval call binding the contract method 0x8126c38a. 240 // 241 // Solidity: function allPunksAssigned() view returns(bool) 242 func (_CryptoPunksMarket *CryptoPunksMarketSession) AllPunksAssigned() (bool, error) { 243 return _CryptoPunksMarket.Contract.AllPunksAssigned(&_CryptoPunksMarket.CallOpts) 244 } 245 246 // AllPunksAssigned is a free data retrieval call binding the contract method 0x8126c38a. 247 // 248 // Solidity: function allPunksAssigned() view returns(bool) 249 func (_CryptoPunksMarket *CryptoPunksMarketCallerSession) AllPunksAssigned() (bool, error) { 250 return _CryptoPunksMarket.Contract.AllPunksAssigned(&_CryptoPunksMarket.CallOpts) 251 } 252 253 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 254 // 255 // Solidity: function balanceOf(address ) view returns(uint256) 256 func (_CryptoPunksMarket *CryptoPunksMarketCaller) BalanceOf(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { 257 var out []interface{} 258 err := _CryptoPunksMarket.contract.Call(opts, &out, "balanceOf", arg0) 259 260 if err != nil { 261 return *new(*big.Int), err 262 } 263 264 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 265 266 return out0, err 267 268 } 269 270 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 271 // 272 // Solidity: function balanceOf(address ) view returns(uint256) 273 func (_CryptoPunksMarket *CryptoPunksMarketSession) BalanceOf(arg0 common.Address) (*big.Int, error) { 274 return _CryptoPunksMarket.Contract.BalanceOf(&_CryptoPunksMarket.CallOpts, arg0) 275 } 276 277 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 278 // 279 // Solidity: function balanceOf(address ) view returns(uint256) 280 func (_CryptoPunksMarket *CryptoPunksMarketCallerSession) BalanceOf(arg0 common.Address) (*big.Int, error) { 281 return _CryptoPunksMarket.Contract.BalanceOf(&_CryptoPunksMarket.CallOpts, arg0) 282 } 283 284 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 285 // 286 // Solidity: function decimals() view returns(uint8) 287 func (_CryptoPunksMarket *CryptoPunksMarketCaller) Decimals(opts *bind.CallOpts) (uint8, error) { 288 var out []interface{} 289 err := _CryptoPunksMarket.contract.Call(opts, &out, "decimals") 290 291 if err != nil { 292 return *new(uint8), err 293 } 294 295 out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) 296 297 return out0, err 298 299 } 300 301 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 302 // 303 // Solidity: function decimals() view returns(uint8) 304 func (_CryptoPunksMarket *CryptoPunksMarketSession) Decimals() (uint8, error) { 305 return _CryptoPunksMarket.Contract.Decimals(&_CryptoPunksMarket.CallOpts) 306 } 307 308 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 309 // 310 // Solidity: function decimals() view returns(uint8) 311 func (_CryptoPunksMarket *CryptoPunksMarketCallerSession) Decimals() (uint8, error) { 312 return _CryptoPunksMarket.Contract.Decimals(&_CryptoPunksMarket.CallOpts) 313 } 314 315 // ImageHash is a free data retrieval call binding the contract method 0x51605d80. 316 // 317 // Solidity: function imageHash() view returns(string) 318 func (_CryptoPunksMarket *CryptoPunksMarketCaller) ImageHash(opts *bind.CallOpts) (string, error) { 319 var out []interface{} 320 err := _CryptoPunksMarket.contract.Call(opts, &out, "imageHash") 321 322 if err != nil { 323 return *new(string), err 324 } 325 326 out0 := *abi.ConvertType(out[0], new(string)).(*string) 327 328 return out0, err 329 330 } 331 332 // ImageHash is a free data retrieval call binding the contract method 0x51605d80. 333 // 334 // Solidity: function imageHash() view returns(string) 335 func (_CryptoPunksMarket *CryptoPunksMarketSession) ImageHash() (string, error) { 336 return _CryptoPunksMarket.Contract.ImageHash(&_CryptoPunksMarket.CallOpts) 337 } 338 339 // ImageHash is a free data retrieval call binding the contract method 0x51605d80. 340 // 341 // Solidity: function imageHash() view returns(string) 342 func (_CryptoPunksMarket *CryptoPunksMarketCallerSession) ImageHash() (string, error) { 343 return _CryptoPunksMarket.Contract.ImageHash(&_CryptoPunksMarket.CallOpts) 344 } 345 346 // Name is a free data retrieval call binding the contract method 0x06fdde03. 347 // 348 // Solidity: function name() view returns(string) 349 func (_CryptoPunksMarket *CryptoPunksMarketCaller) Name(opts *bind.CallOpts) (string, error) { 350 var out []interface{} 351 err := _CryptoPunksMarket.contract.Call(opts, &out, "name") 352 353 if err != nil { 354 return *new(string), err 355 } 356 357 out0 := *abi.ConvertType(out[0], new(string)).(*string) 358 359 return out0, err 360 361 } 362 363 // Name is a free data retrieval call binding the contract method 0x06fdde03. 364 // 365 // Solidity: function name() view returns(string) 366 func (_CryptoPunksMarket *CryptoPunksMarketSession) Name() (string, error) { 367 return _CryptoPunksMarket.Contract.Name(&_CryptoPunksMarket.CallOpts) 368 } 369 370 // Name is a free data retrieval call binding the contract method 0x06fdde03. 371 // 372 // Solidity: function name() view returns(string) 373 func (_CryptoPunksMarket *CryptoPunksMarketCallerSession) Name() (string, error) { 374 return _CryptoPunksMarket.Contract.Name(&_CryptoPunksMarket.CallOpts) 375 } 376 377 // NextPunkIndexToAssign is a free data retrieval call binding the contract method 0x52f29a25. 378 // 379 // Solidity: function nextPunkIndexToAssign() view returns(uint256) 380 func (_CryptoPunksMarket *CryptoPunksMarketCaller) NextPunkIndexToAssign(opts *bind.CallOpts) (*big.Int, error) { 381 var out []interface{} 382 err := _CryptoPunksMarket.contract.Call(opts, &out, "nextPunkIndexToAssign") 383 384 if err != nil { 385 return *new(*big.Int), err 386 } 387 388 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 389 390 return out0, err 391 392 } 393 394 // NextPunkIndexToAssign is a free data retrieval call binding the contract method 0x52f29a25. 395 // 396 // Solidity: function nextPunkIndexToAssign() view returns(uint256) 397 func (_CryptoPunksMarket *CryptoPunksMarketSession) NextPunkIndexToAssign() (*big.Int, error) { 398 return _CryptoPunksMarket.Contract.NextPunkIndexToAssign(&_CryptoPunksMarket.CallOpts) 399 } 400 401 // NextPunkIndexToAssign is a free data retrieval call binding the contract method 0x52f29a25. 402 // 403 // Solidity: function nextPunkIndexToAssign() view returns(uint256) 404 func (_CryptoPunksMarket *CryptoPunksMarketCallerSession) NextPunkIndexToAssign() (*big.Int, error) { 405 return _CryptoPunksMarket.Contract.NextPunkIndexToAssign(&_CryptoPunksMarket.CallOpts) 406 } 407 408 // PendingWithdrawals is a free data retrieval call binding the contract method 0xf3f43703. 409 // 410 // Solidity: function pendingWithdrawals(address ) view returns(uint256) 411 func (_CryptoPunksMarket *CryptoPunksMarketCaller) PendingWithdrawals(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { 412 var out []interface{} 413 err := _CryptoPunksMarket.contract.Call(opts, &out, "pendingWithdrawals", arg0) 414 415 if err != nil { 416 return *new(*big.Int), err 417 } 418 419 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 420 421 return out0, err 422 423 } 424 425 // PendingWithdrawals is a free data retrieval call binding the contract method 0xf3f43703. 426 // 427 // Solidity: function pendingWithdrawals(address ) view returns(uint256) 428 func (_CryptoPunksMarket *CryptoPunksMarketSession) PendingWithdrawals(arg0 common.Address) (*big.Int, error) { 429 return _CryptoPunksMarket.Contract.PendingWithdrawals(&_CryptoPunksMarket.CallOpts, arg0) 430 } 431 432 // PendingWithdrawals is a free data retrieval call binding the contract method 0xf3f43703. 433 // 434 // Solidity: function pendingWithdrawals(address ) view returns(uint256) 435 func (_CryptoPunksMarket *CryptoPunksMarketCallerSession) PendingWithdrawals(arg0 common.Address) (*big.Int, error) { 436 return _CryptoPunksMarket.Contract.PendingWithdrawals(&_CryptoPunksMarket.CallOpts, arg0) 437 } 438 439 // PunkBids is a free data retrieval call binding the contract method 0x6e743fa9. 440 // 441 // Solidity: function punkBids(uint256 ) view returns(bool hasBid, uint256 punkIndex, address bidder, uint256 value) 442 func (_CryptoPunksMarket *CryptoPunksMarketCaller) PunkBids(opts *bind.CallOpts, arg0 *big.Int) (struct { 443 HasBid bool 444 PunkIndex *big.Int 445 Bidder common.Address 446 Value *big.Int 447 }, error) { 448 var out []interface{} 449 err := _CryptoPunksMarket.contract.Call(opts, &out, "punkBids", arg0) 450 451 outstruct := new(struct { 452 HasBid bool 453 PunkIndex *big.Int 454 Bidder common.Address 455 Value *big.Int 456 }) 457 if err != nil { 458 return *outstruct, err 459 } 460 461 outstruct.HasBid = *abi.ConvertType(out[0], new(bool)).(*bool) 462 outstruct.PunkIndex = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) 463 outstruct.Bidder = *abi.ConvertType(out[2], new(common.Address)).(*common.Address) 464 outstruct.Value = *abi.ConvertType(out[3], new(*big.Int)).(**big.Int) 465 466 return *outstruct, err 467 468 } 469 470 // PunkBids is a free data retrieval call binding the contract method 0x6e743fa9. 471 // 472 // Solidity: function punkBids(uint256 ) view returns(bool hasBid, uint256 punkIndex, address bidder, uint256 value) 473 func (_CryptoPunksMarket *CryptoPunksMarketSession) PunkBids(arg0 *big.Int) (struct { 474 HasBid bool 475 PunkIndex *big.Int 476 Bidder common.Address 477 Value *big.Int 478 }, error) { 479 return _CryptoPunksMarket.Contract.PunkBids(&_CryptoPunksMarket.CallOpts, arg0) 480 } 481 482 // PunkBids is a free data retrieval call binding the contract method 0x6e743fa9. 483 // 484 // Solidity: function punkBids(uint256 ) view returns(bool hasBid, uint256 punkIndex, address bidder, uint256 value) 485 func (_CryptoPunksMarket *CryptoPunksMarketCallerSession) PunkBids(arg0 *big.Int) (struct { 486 HasBid bool 487 PunkIndex *big.Int 488 Bidder common.Address 489 Value *big.Int 490 }, error) { 491 return _CryptoPunksMarket.Contract.PunkBids(&_CryptoPunksMarket.CallOpts, arg0) 492 } 493 494 // PunkIndexToAddress is a free data retrieval call binding the contract method 0x58178168. 495 // 496 // Solidity: function punkIndexToAddress(uint256 ) view returns(address) 497 func (_CryptoPunksMarket *CryptoPunksMarketCaller) PunkIndexToAddress(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error) { 498 var out []interface{} 499 err := _CryptoPunksMarket.contract.Call(opts, &out, "punkIndexToAddress", arg0) 500 501 if err != nil { 502 return *new(common.Address), err 503 } 504 505 out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) 506 507 return out0, err 508 509 } 510 511 // PunkIndexToAddress is a free data retrieval call binding the contract method 0x58178168. 512 // 513 // Solidity: function punkIndexToAddress(uint256 ) view returns(address) 514 func (_CryptoPunksMarket *CryptoPunksMarketSession) PunkIndexToAddress(arg0 *big.Int) (common.Address, error) { 515 return _CryptoPunksMarket.Contract.PunkIndexToAddress(&_CryptoPunksMarket.CallOpts, arg0) 516 } 517 518 // PunkIndexToAddress is a free data retrieval call binding the contract method 0x58178168. 519 // 520 // Solidity: function punkIndexToAddress(uint256 ) view returns(address) 521 func (_CryptoPunksMarket *CryptoPunksMarketCallerSession) PunkIndexToAddress(arg0 *big.Int) (common.Address, error) { 522 return _CryptoPunksMarket.Contract.PunkIndexToAddress(&_CryptoPunksMarket.CallOpts, arg0) 523 } 524 525 // PunksOfferedForSale is a free data retrieval call binding the contract method 0x088f11f3. 526 // 527 // Solidity: function punksOfferedForSale(uint256 ) view returns(bool isForSale, uint256 punkIndex, address seller, uint256 minValue, address onlySellTo) 528 func (_CryptoPunksMarket *CryptoPunksMarketCaller) PunksOfferedForSale(opts *bind.CallOpts, arg0 *big.Int) (struct { 529 IsForSale bool 530 PunkIndex *big.Int 531 Seller common.Address 532 MinValue *big.Int 533 OnlySellTo common.Address 534 }, error) { 535 var out []interface{} 536 err := _CryptoPunksMarket.contract.Call(opts, &out, "punksOfferedForSale", arg0) 537 538 outstruct := new(struct { 539 IsForSale bool 540 PunkIndex *big.Int 541 Seller common.Address 542 MinValue *big.Int 543 OnlySellTo common.Address 544 }) 545 if err != nil { 546 return *outstruct, err 547 } 548 549 outstruct.IsForSale = *abi.ConvertType(out[0], new(bool)).(*bool) 550 outstruct.PunkIndex = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) 551 outstruct.Seller = *abi.ConvertType(out[2], new(common.Address)).(*common.Address) 552 outstruct.MinValue = *abi.ConvertType(out[3], new(*big.Int)).(**big.Int) 553 outstruct.OnlySellTo = *abi.ConvertType(out[4], new(common.Address)).(*common.Address) 554 555 return *outstruct, err 556 557 } 558 559 // PunksOfferedForSale is a free data retrieval call binding the contract method 0x088f11f3. 560 // 561 // Solidity: function punksOfferedForSale(uint256 ) view returns(bool isForSale, uint256 punkIndex, address seller, uint256 minValue, address onlySellTo) 562 func (_CryptoPunksMarket *CryptoPunksMarketSession) PunksOfferedForSale(arg0 *big.Int) (struct { 563 IsForSale bool 564 PunkIndex *big.Int 565 Seller common.Address 566 MinValue *big.Int 567 OnlySellTo common.Address 568 }, error) { 569 return _CryptoPunksMarket.Contract.PunksOfferedForSale(&_CryptoPunksMarket.CallOpts, arg0) 570 } 571 572 // PunksOfferedForSale is a free data retrieval call binding the contract method 0x088f11f3. 573 // 574 // Solidity: function punksOfferedForSale(uint256 ) view returns(bool isForSale, uint256 punkIndex, address seller, uint256 minValue, address onlySellTo) 575 func (_CryptoPunksMarket *CryptoPunksMarketCallerSession) PunksOfferedForSale(arg0 *big.Int) (struct { 576 IsForSale bool 577 PunkIndex *big.Int 578 Seller common.Address 579 MinValue *big.Int 580 OnlySellTo common.Address 581 }, error) { 582 return _CryptoPunksMarket.Contract.PunksOfferedForSale(&_CryptoPunksMarket.CallOpts, arg0) 583 } 584 585 // PunksRemainingToAssign is a free data retrieval call binding the contract method 0xc0d6ce63. 586 // 587 // Solidity: function punksRemainingToAssign() view returns(uint256) 588 func (_CryptoPunksMarket *CryptoPunksMarketCaller) PunksRemainingToAssign(opts *bind.CallOpts) (*big.Int, error) { 589 var out []interface{} 590 err := _CryptoPunksMarket.contract.Call(opts, &out, "punksRemainingToAssign") 591 592 if err != nil { 593 return *new(*big.Int), err 594 } 595 596 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 597 598 return out0, err 599 600 } 601 602 // PunksRemainingToAssign is a free data retrieval call binding the contract method 0xc0d6ce63. 603 // 604 // Solidity: function punksRemainingToAssign() view returns(uint256) 605 func (_CryptoPunksMarket *CryptoPunksMarketSession) PunksRemainingToAssign() (*big.Int, error) { 606 return _CryptoPunksMarket.Contract.PunksRemainingToAssign(&_CryptoPunksMarket.CallOpts) 607 } 608 609 // PunksRemainingToAssign is a free data retrieval call binding the contract method 0xc0d6ce63. 610 // 611 // Solidity: function punksRemainingToAssign() view returns(uint256) 612 func (_CryptoPunksMarket *CryptoPunksMarketCallerSession) PunksRemainingToAssign() (*big.Int, error) { 613 return _CryptoPunksMarket.Contract.PunksRemainingToAssign(&_CryptoPunksMarket.CallOpts) 614 } 615 616 // Standard is a free data retrieval call binding the contract method 0x5a3b7e42. 617 // 618 // Solidity: function standard() view returns(string) 619 func (_CryptoPunksMarket *CryptoPunksMarketCaller) Standard(opts *bind.CallOpts) (string, error) { 620 var out []interface{} 621 err := _CryptoPunksMarket.contract.Call(opts, &out, "standard") 622 623 if err != nil { 624 return *new(string), err 625 } 626 627 out0 := *abi.ConvertType(out[0], new(string)).(*string) 628 629 return out0, err 630 631 } 632 633 // Standard is a free data retrieval call binding the contract method 0x5a3b7e42. 634 // 635 // Solidity: function standard() view returns(string) 636 func (_CryptoPunksMarket *CryptoPunksMarketSession) Standard() (string, error) { 637 return _CryptoPunksMarket.Contract.Standard(&_CryptoPunksMarket.CallOpts) 638 } 639 640 // Standard is a free data retrieval call binding the contract method 0x5a3b7e42. 641 // 642 // Solidity: function standard() view returns(string) 643 func (_CryptoPunksMarket *CryptoPunksMarketCallerSession) Standard() (string, error) { 644 return _CryptoPunksMarket.Contract.Standard(&_CryptoPunksMarket.CallOpts) 645 } 646 647 // Symbol is a free data retrieval call binding the contract method 0x95d89b41. 648 // 649 // Solidity: function symbol() view returns(string) 650 func (_CryptoPunksMarket *CryptoPunksMarketCaller) Symbol(opts *bind.CallOpts) (string, error) { 651 var out []interface{} 652 err := _CryptoPunksMarket.contract.Call(opts, &out, "symbol") 653 654 if err != nil { 655 return *new(string), err 656 } 657 658 out0 := *abi.ConvertType(out[0], new(string)).(*string) 659 660 return out0, err 661 662 } 663 664 // Symbol is a free data retrieval call binding the contract method 0x95d89b41. 665 // 666 // Solidity: function symbol() view returns(string) 667 func (_CryptoPunksMarket *CryptoPunksMarketSession) Symbol() (string, error) { 668 return _CryptoPunksMarket.Contract.Symbol(&_CryptoPunksMarket.CallOpts) 669 } 670 671 // Symbol is a free data retrieval call binding the contract method 0x95d89b41. 672 // 673 // Solidity: function symbol() view returns(string) 674 func (_CryptoPunksMarket *CryptoPunksMarketCallerSession) Symbol() (string, error) { 675 return _CryptoPunksMarket.Contract.Symbol(&_CryptoPunksMarket.CallOpts) 676 } 677 678 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 679 // 680 // Solidity: function totalSupply() view returns(uint256) 681 func (_CryptoPunksMarket *CryptoPunksMarketCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 682 var out []interface{} 683 err := _CryptoPunksMarket.contract.Call(opts, &out, "totalSupply") 684 685 if err != nil { 686 return *new(*big.Int), err 687 } 688 689 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 690 691 return out0, err 692 693 } 694 695 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 696 // 697 // Solidity: function totalSupply() view returns(uint256) 698 func (_CryptoPunksMarket *CryptoPunksMarketSession) TotalSupply() (*big.Int, error) { 699 return _CryptoPunksMarket.Contract.TotalSupply(&_CryptoPunksMarket.CallOpts) 700 } 701 702 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 703 // 704 // Solidity: function totalSupply() view returns(uint256) 705 func (_CryptoPunksMarket *CryptoPunksMarketCallerSession) TotalSupply() (*big.Int, error) { 706 return _CryptoPunksMarket.Contract.TotalSupply(&_CryptoPunksMarket.CallOpts) 707 } 708 709 // AcceptBidForPunk is a paid mutator transaction binding the contract method 0x23165b75. 710 // 711 // Solidity: function acceptBidForPunk(uint256 punkIndex, uint256 minPrice) returns() 712 func (_CryptoPunksMarket *CryptoPunksMarketTransactor) AcceptBidForPunk(opts *bind.TransactOpts, punkIndex *big.Int, minPrice *big.Int) (*types.Transaction, error) { 713 return _CryptoPunksMarket.contract.Transact(opts, "acceptBidForPunk", punkIndex, minPrice) 714 } 715 716 // AcceptBidForPunk is a paid mutator transaction binding the contract method 0x23165b75. 717 // 718 // Solidity: function acceptBidForPunk(uint256 punkIndex, uint256 minPrice) returns() 719 func (_CryptoPunksMarket *CryptoPunksMarketSession) AcceptBidForPunk(punkIndex *big.Int, minPrice *big.Int) (*types.Transaction, error) { 720 return _CryptoPunksMarket.Contract.AcceptBidForPunk(&_CryptoPunksMarket.TransactOpts, punkIndex, minPrice) 721 } 722 723 // AcceptBidForPunk is a paid mutator transaction binding the contract method 0x23165b75. 724 // 725 // Solidity: function acceptBidForPunk(uint256 punkIndex, uint256 minPrice) returns() 726 func (_CryptoPunksMarket *CryptoPunksMarketTransactorSession) AcceptBidForPunk(punkIndex *big.Int, minPrice *big.Int) (*types.Transaction, error) { 727 return _CryptoPunksMarket.Contract.AcceptBidForPunk(&_CryptoPunksMarket.TransactOpts, punkIndex, minPrice) 728 } 729 730 // AllInitialOwnersAssigned is a paid mutator transaction binding the contract method 0x7ecedac9. 731 // 732 // Solidity: function allInitialOwnersAssigned() returns() 733 func (_CryptoPunksMarket *CryptoPunksMarketTransactor) AllInitialOwnersAssigned(opts *bind.TransactOpts) (*types.Transaction, error) { 734 return _CryptoPunksMarket.contract.Transact(opts, "allInitialOwnersAssigned") 735 } 736 737 // AllInitialOwnersAssigned is a paid mutator transaction binding the contract method 0x7ecedac9. 738 // 739 // Solidity: function allInitialOwnersAssigned() returns() 740 func (_CryptoPunksMarket *CryptoPunksMarketSession) AllInitialOwnersAssigned() (*types.Transaction, error) { 741 return _CryptoPunksMarket.Contract.AllInitialOwnersAssigned(&_CryptoPunksMarket.TransactOpts) 742 } 743 744 // AllInitialOwnersAssigned is a paid mutator transaction binding the contract method 0x7ecedac9. 745 // 746 // Solidity: function allInitialOwnersAssigned() returns() 747 func (_CryptoPunksMarket *CryptoPunksMarketTransactorSession) AllInitialOwnersAssigned() (*types.Transaction, error) { 748 return _CryptoPunksMarket.Contract.AllInitialOwnersAssigned(&_CryptoPunksMarket.TransactOpts) 749 } 750 751 // BuyPunk is a paid mutator transaction binding the contract method 0x8264fe98. 752 // 753 // Solidity: function buyPunk(uint256 punkIndex) payable returns() 754 func (_CryptoPunksMarket *CryptoPunksMarketTransactor) BuyPunk(opts *bind.TransactOpts, punkIndex *big.Int) (*types.Transaction, error) { 755 return _CryptoPunksMarket.contract.Transact(opts, "buyPunk", punkIndex) 756 } 757 758 // BuyPunk is a paid mutator transaction binding the contract method 0x8264fe98. 759 // 760 // Solidity: function buyPunk(uint256 punkIndex) payable returns() 761 func (_CryptoPunksMarket *CryptoPunksMarketSession) BuyPunk(punkIndex *big.Int) (*types.Transaction, error) { 762 return _CryptoPunksMarket.Contract.BuyPunk(&_CryptoPunksMarket.TransactOpts, punkIndex) 763 } 764 765 // BuyPunk is a paid mutator transaction binding the contract method 0x8264fe98. 766 // 767 // Solidity: function buyPunk(uint256 punkIndex) payable returns() 768 func (_CryptoPunksMarket *CryptoPunksMarketTransactorSession) BuyPunk(punkIndex *big.Int) (*types.Transaction, error) { 769 return _CryptoPunksMarket.Contract.BuyPunk(&_CryptoPunksMarket.TransactOpts, punkIndex) 770 } 771 772 // EnterBidForPunk is a paid mutator transaction binding the contract method 0x091dbfd2. 773 // 774 // Solidity: function enterBidForPunk(uint256 punkIndex) payable returns() 775 func (_CryptoPunksMarket *CryptoPunksMarketTransactor) EnterBidForPunk(opts *bind.TransactOpts, punkIndex *big.Int) (*types.Transaction, error) { 776 return _CryptoPunksMarket.contract.Transact(opts, "enterBidForPunk", punkIndex) 777 } 778 779 // EnterBidForPunk is a paid mutator transaction binding the contract method 0x091dbfd2. 780 // 781 // Solidity: function enterBidForPunk(uint256 punkIndex) payable returns() 782 func (_CryptoPunksMarket *CryptoPunksMarketSession) EnterBidForPunk(punkIndex *big.Int) (*types.Transaction, error) { 783 return _CryptoPunksMarket.Contract.EnterBidForPunk(&_CryptoPunksMarket.TransactOpts, punkIndex) 784 } 785 786 // EnterBidForPunk is a paid mutator transaction binding the contract method 0x091dbfd2. 787 // 788 // Solidity: function enterBidForPunk(uint256 punkIndex) payable returns() 789 func (_CryptoPunksMarket *CryptoPunksMarketTransactorSession) EnterBidForPunk(punkIndex *big.Int) (*types.Transaction, error) { 790 return _CryptoPunksMarket.Contract.EnterBidForPunk(&_CryptoPunksMarket.TransactOpts, punkIndex) 791 } 792 793 // GetPunk is a paid mutator transaction binding the contract method 0xc81d1d5b. 794 // 795 // Solidity: function getPunk(uint256 punkIndex) returns() 796 func (_CryptoPunksMarket *CryptoPunksMarketTransactor) GetPunk(opts *bind.TransactOpts, punkIndex *big.Int) (*types.Transaction, error) { 797 return _CryptoPunksMarket.contract.Transact(opts, "getPunk", punkIndex) 798 } 799 800 // GetPunk is a paid mutator transaction binding the contract method 0xc81d1d5b. 801 // 802 // Solidity: function getPunk(uint256 punkIndex) returns() 803 func (_CryptoPunksMarket *CryptoPunksMarketSession) GetPunk(punkIndex *big.Int) (*types.Transaction, error) { 804 return _CryptoPunksMarket.Contract.GetPunk(&_CryptoPunksMarket.TransactOpts, punkIndex) 805 } 806 807 // GetPunk is a paid mutator transaction binding the contract method 0xc81d1d5b. 808 // 809 // Solidity: function getPunk(uint256 punkIndex) returns() 810 func (_CryptoPunksMarket *CryptoPunksMarketTransactorSession) GetPunk(punkIndex *big.Int) (*types.Transaction, error) { 811 return _CryptoPunksMarket.Contract.GetPunk(&_CryptoPunksMarket.TransactOpts, punkIndex) 812 } 813 814 // OfferPunkForSale is a paid mutator transaction binding the contract method 0xc44193c3. 815 // 816 // Solidity: function offerPunkForSale(uint256 punkIndex, uint256 minSalePriceInWei) returns() 817 func (_CryptoPunksMarket *CryptoPunksMarketTransactor) OfferPunkForSale(opts *bind.TransactOpts, punkIndex *big.Int, minSalePriceInWei *big.Int) (*types.Transaction, error) { 818 return _CryptoPunksMarket.contract.Transact(opts, "offerPunkForSale", punkIndex, minSalePriceInWei) 819 } 820 821 // OfferPunkForSale is a paid mutator transaction binding the contract method 0xc44193c3. 822 // 823 // Solidity: function offerPunkForSale(uint256 punkIndex, uint256 minSalePriceInWei) returns() 824 func (_CryptoPunksMarket *CryptoPunksMarketSession) OfferPunkForSale(punkIndex *big.Int, minSalePriceInWei *big.Int) (*types.Transaction, error) { 825 return _CryptoPunksMarket.Contract.OfferPunkForSale(&_CryptoPunksMarket.TransactOpts, punkIndex, minSalePriceInWei) 826 } 827 828 // OfferPunkForSale is a paid mutator transaction binding the contract method 0xc44193c3. 829 // 830 // Solidity: function offerPunkForSale(uint256 punkIndex, uint256 minSalePriceInWei) returns() 831 func (_CryptoPunksMarket *CryptoPunksMarketTransactorSession) OfferPunkForSale(punkIndex *big.Int, minSalePriceInWei *big.Int) (*types.Transaction, error) { 832 return _CryptoPunksMarket.Contract.OfferPunkForSale(&_CryptoPunksMarket.TransactOpts, punkIndex, minSalePriceInWei) 833 } 834 835 // OfferPunkForSaleToAddress is a paid mutator transaction binding the contract method 0xbf31196f. 836 // 837 // Solidity: function offerPunkForSaleToAddress(uint256 punkIndex, uint256 minSalePriceInWei, address toAddress) returns() 838 func (_CryptoPunksMarket *CryptoPunksMarketTransactor) OfferPunkForSaleToAddress(opts *bind.TransactOpts, punkIndex *big.Int, minSalePriceInWei *big.Int, toAddress common.Address) (*types.Transaction, error) { 839 return _CryptoPunksMarket.contract.Transact(opts, "offerPunkForSaleToAddress", punkIndex, minSalePriceInWei, toAddress) 840 } 841 842 // OfferPunkForSaleToAddress is a paid mutator transaction binding the contract method 0xbf31196f. 843 // 844 // Solidity: function offerPunkForSaleToAddress(uint256 punkIndex, uint256 minSalePriceInWei, address toAddress) returns() 845 func (_CryptoPunksMarket *CryptoPunksMarketSession) OfferPunkForSaleToAddress(punkIndex *big.Int, minSalePriceInWei *big.Int, toAddress common.Address) (*types.Transaction, error) { 846 return _CryptoPunksMarket.Contract.OfferPunkForSaleToAddress(&_CryptoPunksMarket.TransactOpts, punkIndex, minSalePriceInWei, toAddress) 847 } 848 849 // OfferPunkForSaleToAddress is a paid mutator transaction binding the contract method 0xbf31196f. 850 // 851 // Solidity: function offerPunkForSaleToAddress(uint256 punkIndex, uint256 minSalePriceInWei, address toAddress) returns() 852 func (_CryptoPunksMarket *CryptoPunksMarketTransactorSession) OfferPunkForSaleToAddress(punkIndex *big.Int, minSalePriceInWei *big.Int, toAddress common.Address) (*types.Transaction, error) { 853 return _CryptoPunksMarket.Contract.OfferPunkForSaleToAddress(&_CryptoPunksMarket.TransactOpts, punkIndex, minSalePriceInWei, toAddress) 854 } 855 856 // PunkNoLongerForSale is a paid mutator transaction binding the contract method 0xf6eeff1e. 857 // 858 // Solidity: function punkNoLongerForSale(uint256 punkIndex) returns() 859 func (_CryptoPunksMarket *CryptoPunksMarketTransactor) PunkNoLongerForSale(opts *bind.TransactOpts, punkIndex *big.Int) (*types.Transaction, error) { 860 return _CryptoPunksMarket.contract.Transact(opts, "punkNoLongerForSale", punkIndex) 861 } 862 863 // PunkNoLongerForSale is a paid mutator transaction binding the contract method 0xf6eeff1e. 864 // 865 // Solidity: function punkNoLongerForSale(uint256 punkIndex) returns() 866 func (_CryptoPunksMarket *CryptoPunksMarketSession) PunkNoLongerForSale(punkIndex *big.Int) (*types.Transaction, error) { 867 return _CryptoPunksMarket.Contract.PunkNoLongerForSale(&_CryptoPunksMarket.TransactOpts, punkIndex) 868 } 869 870 // PunkNoLongerForSale is a paid mutator transaction binding the contract method 0xf6eeff1e. 871 // 872 // Solidity: function punkNoLongerForSale(uint256 punkIndex) returns() 873 func (_CryptoPunksMarket *CryptoPunksMarketTransactorSession) PunkNoLongerForSale(punkIndex *big.Int) (*types.Transaction, error) { 874 return _CryptoPunksMarket.Contract.PunkNoLongerForSale(&_CryptoPunksMarket.TransactOpts, punkIndex) 875 } 876 877 // SetInitialOwner is a paid mutator transaction binding the contract method 0xa75a9049. 878 // 879 // Solidity: function setInitialOwner(address to, uint256 punkIndex) returns() 880 func (_CryptoPunksMarket *CryptoPunksMarketTransactor) SetInitialOwner(opts *bind.TransactOpts, to common.Address, punkIndex *big.Int) (*types.Transaction, error) { 881 return _CryptoPunksMarket.contract.Transact(opts, "setInitialOwner", to, punkIndex) 882 } 883 884 // SetInitialOwner is a paid mutator transaction binding the contract method 0xa75a9049. 885 // 886 // Solidity: function setInitialOwner(address to, uint256 punkIndex) returns() 887 func (_CryptoPunksMarket *CryptoPunksMarketSession) SetInitialOwner(to common.Address, punkIndex *big.Int) (*types.Transaction, error) { 888 return _CryptoPunksMarket.Contract.SetInitialOwner(&_CryptoPunksMarket.TransactOpts, to, punkIndex) 889 } 890 891 // SetInitialOwner is a paid mutator transaction binding the contract method 0xa75a9049. 892 // 893 // Solidity: function setInitialOwner(address to, uint256 punkIndex) returns() 894 func (_CryptoPunksMarket *CryptoPunksMarketTransactorSession) SetInitialOwner(to common.Address, punkIndex *big.Int) (*types.Transaction, error) { 895 return _CryptoPunksMarket.Contract.SetInitialOwner(&_CryptoPunksMarket.TransactOpts, to, punkIndex) 896 } 897 898 // SetInitialOwners is a paid mutator transaction binding the contract method 0x39c5dde6. 899 // 900 // Solidity: function setInitialOwners(address[] addresses, uint256[] indices) returns() 901 func (_CryptoPunksMarket *CryptoPunksMarketTransactor) SetInitialOwners(opts *bind.TransactOpts, addresses []common.Address, indices []*big.Int) (*types.Transaction, error) { 902 return _CryptoPunksMarket.contract.Transact(opts, "setInitialOwners", addresses, indices) 903 } 904 905 // SetInitialOwners is a paid mutator transaction binding the contract method 0x39c5dde6. 906 // 907 // Solidity: function setInitialOwners(address[] addresses, uint256[] indices) returns() 908 func (_CryptoPunksMarket *CryptoPunksMarketSession) SetInitialOwners(addresses []common.Address, indices []*big.Int) (*types.Transaction, error) { 909 return _CryptoPunksMarket.Contract.SetInitialOwners(&_CryptoPunksMarket.TransactOpts, addresses, indices) 910 } 911 912 // SetInitialOwners is a paid mutator transaction binding the contract method 0x39c5dde6. 913 // 914 // Solidity: function setInitialOwners(address[] addresses, uint256[] indices) returns() 915 func (_CryptoPunksMarket *CryptoPunksMarketTransactorSession) SetInitialOwners(addresses []common.Address, indices []*big.Int) (*types.Transaction, error) { 916 return _CryptoPunksMarket.Contract.SetInitialOwners(&_CryptoPunksMarket.TransactOpts, addresses, indices) 917 } 918 919 // TransferPunk is a paid mutator transaction binding the contract method 0x8b72a2ec. 920 // 921 // Solidity: function transferPunk(address to, uint256 punkIndex) returns() 922 func (_CryptoPunksMarket *CryptoPunksMarketTransactor) TransferPunk(opts *bind.TransactOpts, to common.Address, punkIndex *big.Int) (*types.Transaction, error) { 923 return _CryptoPunksMarket.contract.Transact(opts, "transferPunk", to, punkIndex) 924 } 925 926 // TransferPunk is a paid mutator transaction binding the contract method 0x8b72a2ec. 927 // 928 // Solidity: function transferPunk(address to, uint256 punkIndex) returns() 929 func (_CryptoPunksMarket *CryptoPunksMarketSession) TransferPunk(to common.Address, punkIndex *big.Int) (*types.Transaction, error) { 930 return _CryptoPunksMarket.Contract.TransferPunk(&_CryptoPunksMarket.TransactOpts, to, punkIndex) 931 } 932 933 // TransferPunk is a paid mutator transaction binding the contract method 0x8b72a2ec. 934 // 935 // Solidity: function transferPunk(address to, uint256 punkIndex) returns() 936 func (_CryptoPunksMarket *CryptoPunksMarketTransactorSession) TransferPunk(to common.Address, punkIndex *big.Int) (*types.Transaction, error) { 937 return _CryptoPunksMarket.Contract.TransferPunk(&_CryptoPunksMarket.TransactOpts, to, punkIndex) 938 } 939 940 // Withdraw is a paid mutator transaction binding the contract method 0x3ccfd60b. 941 // 942 // Solidity: function withdraw() returns() 943 func (_CryptoPunksMarket *CryptoPunksMarketTransactor) Withdraw(opts *bind.TransactOpts) (*types.Transaction, error) { 944 return _CryptoPunksMarket.contract.Transact(opts, "withdraw") 945 } 946 947 // Withdraw is a paid mutator transaction binding the contract method 0x3ccfd60b. 948 // 949 // Solidity: function withdraw() returns() 950 func (_CryptoPunksMarket *CryptoPunksMarketSession) Withdraw() (*types.Transaction, error) { 951 return _CryptoPunksMarket.Contract.Withdraw(&_CryptoPunksMarket.TransactOpts) 952 } 953 954 // Withdraw is a paid mutator transaction binding the contract method 0x3ccfd60b. 955 // 956 // Solidity: function withdraw() returns() 957 func (_CryptoPunksMarket *CryptoPunksMarketTransactorSession) Withdraw() (*types.Transaction, error) { 958 return _CryptoPunksMarket.Contract.Withdraw(&_CryptoPunksMarket.TransactOpts) 959 } 960 961 // WithdrawBidForPunk is a paid mutator transaction binding the contract method 0x979bc638. 962 // 963 // Solidity: function withdrawBidForPunk(uint256 punkIndex) returns() 964 func (_CryptoPunksMarket *CryptoPunksMarketTransactor) WithdrawBidForPunk(opts *bind.TransactOpts, punkIndex *big.Int) (*types.Transaction, error) { 965 return _CryptoPunksMarket.contract.Transact(opts, "withdrawBidForPunk", punkIndex) 966 } 967 968 // WithdrawBidForPunk is a paid mutator transaction binding the contract method 0x979bc638. 969 // 970 // Solidity: function withdrawBidForPunk(uint256 punkIndex) returns() 971 func (_CryptoPunksMarket *CryptoPunksMarketSession) WithdrawBidForPunk(punkIndex *big.Int) (*types.Transaction, error) { 972 return _CryptoPunksMarket.Contract.WithdrawBidForPunk(&_CryptoPunksMarket.TransactOpts, punkIndex) 973 } 974 975 // WithdrawBidForPunk is a paid mutator transaction binding the contract method 0x979bc638. 976 // 977 // Solidity: function withdrawBidForPunk(uint256 punkIndex) returns() 978 func (_CryptoPunksMarket *CryptoPunksMarketTransactorSession) WithdrawBidForPunk(punkIndex *big.Int) (*types.Transaction, error) { 979 return _CryptoPunksMarket.Contract.WithdrawBidForPunk(&_CryptoPunksMarket.TransactOpts, punkIndex) 980 } 981 982 // CryptoPunksMarketAssignIterator is returned from FilterAssign and is used to iterate over the raw logs and unpacked data for Assign events raised by the CryptoPunksMarket contract. 983 type CryptoPunksMarketAssignIterator struct { 984 Event *CryptoPunksMarketAssign // Event containing the contract specifics and raw log 985 986 contract *bind.BoundContract // Generic contract to use for unpacking event data 987 event string // Event name to use for unpacking event data 988 989 logs chan types.Log // Log channel receiving the found contract events 990 sub ethereum.Subscription // Subscription for errors, completion and termination 991 done bool // Whether the subscription completed delivering logs 992 fail error // Occurred error to stop iteration 993 } 994 995 // Next advances the iterator to the subsequent event, returning whether there 996 // are any more events found. In case of a retrieval or parsing error, false is 997 // returned and Error() can be queried for the exact failure. 998 func (it *CryptoPunksMarketAssignIterator) Next() bool { 999 // If the iterator failed, stop iterating 1000 if it.fail != nil { 1001 return false 1002 } 1003 // If the iterator completed, deliver directly whatever's available 1004 if it.done { 1005 select { 1006 case log := <-it.logs: 1007 it.Event = new(CryptoPunksMarketAssign) 1008 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1009 it.fail = err 1010 return false 1011 } 1012 it.Event.Raw = log 1013 return true 1014 1015 default: 1016 return false 1017 } 1018 } 1019 // Iterator still in progress, wait for either a data or an error event 1020 select { 1021 case log := <-it.logs: 1022 it.Event = new(CryptoPunksMarketAssign) 1023 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1024 it.fail = err 1025 return false 1026 } 1027 it.Event.Raw = log 1028 return true 1029 1030 case err := <-it.sub.Err(): 1031 it.done = true 1032 it.fail = err 1033 return it.Next() 1034 } 1035 } 1036 1037 // Error returns any retrieval or parsing error occurred during filtering. 1038 func (it *CryptoPunksMarketAssignIterator) Error() error { 1039 return it.fail 1040 } 1041 1042 // Close terminates the iteration process, releasing any pending underlying 1043 // resources. 1044 func (it *CryptoPunksMarketAssignIterator) Close() error { 1045 it.sub.Unsubscribe() 1046 return nil 1047 } 1048 1049 // CryptoPunksMarketAssign represents a Assign event raised by the CryptoPunksMarket contract. 1050 type CryptoPunksMarketAssign struct { 1051 To common.Address 1052 PunkIndex *big.Int 1053 Raw types.Log // Blockchain specific contextual infos 1054 } 1055 1056 // FilterAssign is a free log retrieval operation binding the contract event 0x8a0e37b73a0d9c82e205d4d1a3ff3d0b57ce5f4d7bccf6bac03336dc101cb7ba. 1057 // 1058 // Solidity: event Assign(address indexed to, uint256 punkIndex) 1059 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) FilterAssign(opts *bind.FilterOpts, to []common.Address) (*CryptoPunksMarketAssignIterator, error) { 1060 1061 var toRule []interface{} 1062 for _, toItem := range to { 1063 toRule = append(toRule, toItem) 1064 } 1065 1066 logs, sub, err := _CryptoPunksMarket.contract.FilterLogs(opts, "Assign", toRule) 1067 if err != nil { 1068 return nil, err 1069 } 1070 return &CryptoPunksMarketAssignIterator{contract: _CryptoPunksMarket.contract, event: "Assign", logs: logs, sub: sub}, nil 1071 } 1072 1073 // WatchAssign is a free log subscription operation binding the contract event 0x8a0e37b73a0d9c82e205d4d1a3ff3d0b57ce5f4d7bccf6bac03336dc101cb7ba. 1074 // 1075 // Solidity: event Assign(address indexed to, uint256 punkIndex) 1076 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) WatchAssign(opts *bind.WatchOpts, sink chan<- *CryptoPunksMarketAssign, to []common.Address) (event.Subscription, error) { 1077 1078 var toRule []interface{} 1079 for _, toItem := range to { 1080 toRule = append(toRule, toItem) 1081 } 1082 1083 logs, sub, err := _CryptoPunksMarket.contract.WatchLogs(opts, "Assign", toRule) 1084 if err != nil { 1085 return nil, err 1086 } 1087 return event.NewSubscription(func(quit <-chan struct{}) error { 1088 defer sub.Unsubscribe() 1089 for { 1090 select { 1091 case log := <-logs: 1092 // New log arrived, parse the event and forward to the user 1093 event := new(CryptoPunksMarketAssign) 1094 if err := _CryptoPunksMarket.contract.UnpackLog(event, "Assign", log); err != nil { 1095 return err 1096 } 1097 event.Raw = log 1098 1099 select { 1100 case sink <- event: 1101 case err := <-sub.Err(): 1102 return err 1103 case <-quit: 1104 return nil 1105 } 1106 case err := <-sub.Err(): 1107 return err 1108 case <-quit: 1109 return nil 1110 } 1111 } 1112 }), nil 1113 } 1114 1115 // ParseAssign is a log parse operation binding the contract event 0x8a0e37b73a0d9c82e205d4d1a3ff3d0b57ce5f4d7bccf6bac03336dc101cb7ba. 1116 // 1117 // Solidity: event Assign(address indexed to, uint256 punkIndex) 1118 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) ParseAssign(log types.Log) (*CryptoPunksMarketAssign, error) { 1119 event := new(CryptoPunksMarketAssign) 1120 if err := _CryptoPunksMarket.contract.UnpackLog(event, "Assign", log); err != nil { 1121 return nil, err 1122 } 1123 event.Raw = log 1124 return event, nil 1125 } 1126 1127 // CryptoPunksMarketPunkBidEnteredIterator is returned from FilterPunkBidEntered and is used to iterate over the raw logs and unpacked data for PunkBidEntered events raised by the CryptoPunksMarket contract. 1128 type CryptoPunksMarketPunkBidEnteredIterator struct { 1129 Event *CryptoPunksMarketPunkBidEntered // Event containing the contract specifics and raw log 1130 1131 contract *bind.BoundContract // Generic contract to use for unpacking event data 1132 event string // Event name to use for unpacking event data 1133 1134 logs chan types.Log // Log channel receiving the found contract events 1135 sub ethereum.Subscription // Subscription for errors, completion and termination 1136 done bool // Whether the subscription completed delivering logs 1137 fail error // Occurred error to stop iteration 1138 } 1139 1140 // Next advances the iterator to the subsequent event, returning whether there 1141 // are any more events found. In case of a retrieval or parsing error, false is 1142 // returned and Error() can be queried for the exact failure. 1143 func (it *CryptoPunksMarketPunkBidEnteredIterator) Next() bool { 1144 // If the iterator failed, stop iterating 1145 if it.fail != nil { 1146 return false 1147 } 1148 // If the iterator completed, deliver directly whatever's available 1149 if it.done { 1150 select { 1151 case log := <-it.logs: 1152 it.Event = new(CryptoPunksMarketPunkBidEntered) 1153 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1154 it.fail = err 1155 return false 1156 } 1157 it.Event.Raw = log 1158 return true 1159 1160 default: 1161 return false 1162 } 1163 } 1164 // Iterator still in progress, wait for either a data or an error event 1165 select { 1166 case log := <-it.logs: 1167 it.Event = new(CryptoPunksMarketPunkBidEntered) 1168 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1169 it.fail = err 1170 return false 1171 } 1172 it.Event.Raw = log 1173 return true 1174 1175 case err := <-it.sub.Err(): 1176 it.done = true 1177 it.fail = err 1178 return it.Next() 1179 } 1180 } 1181 1182 // Error returns any retrieval or parsing error occurred during filtering. 1183 func (it *CryptoPunksMarketPunkBidEnteredIterator) Error() error { 1184 return it.fail 1185 } 1186 1187 // Close terminates the iteration process, releasing any pending underlying 1188 // resources. 1189 func (it *CryptoPunksMarketPunkBidEnteredIterator) Close() error { 1190 it.sub.Unsubscribe() 1191 return nil 1192 } 1193 1194 // CryptoPunksMarketPunkBidEntered represents a PunkBidEntered event raised by the CryptoPunksMarket contract. 1195 type CryptoPunksMarketPunkBidEntered struct { 1196 PunkIndex *big.Int 1197 Value *big.Int 1198 FromAddress common.Address 1199 Raw types.Log // Blockchain specific contextual infos 1200 } 1201 1202 // FilterPunkBidEntered is a free log retrieval operation binding the contract event 0x5b859394fabae0c1ba88baffe67e751ab5248d2e879028b8c8d6897b0519f56a. 1203 // 1204 // Solidity: event PunkBidEntered(uint256 indexed punkIndex, uint256 value, address indexed fromAddress) 1205 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) FilterPunkBidEntered(opts *bind.FilterOpts, punkIndex []*big.Int, fromAddress []common.Address) (*CryptoPunksMarketPunkBidEnteredIterator, error) { 1206 1207 var punkIndexRule []interface{} 1208 for _, punkIndexItem := range punkIndex { 1209 punkIndexRule = append(punkIndexRule, punkIndexItem) 1210 } 1211 1212 var fromAddressRule []interface{} 1213 for _, fromAddressItem := range fromAddress { 1214 fromAddressRule = append(fromAddressRule, fromAddressItem) 1215 } 1216 1217 logs, sub, err := _CryptoPunksMarket.contract.FilterLogs(opts, "PunkBidEntered", punkIndexRule, fromAddressRule) 1218 if err != nil { 1219 return nil, err 1220 } 1221 return &CryptoPunksMarketPunkBidEnteredIterator{contract: _CryptoPunksMarket.contract, event: "PunkBidEntered", logs: logs, sub: sub}, nil 1222 } 1223 1224 // WatchPunkBidEntered is a free log subscription operation binding the contract event 0x5b859394fabae0c1ba88baffe67e751ab5248d2e879028b8c8d6897b0519f56a. 1225 // 1226 // Solidity: event PunkBidEntered(uint256 indexed punkIndex, uint256 value, address indexed fromAddress) 1227 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) WatchPunkBidEntered(opts *bind.WatchOpts, sink chan<- *CryptoPunksMarketPunkBidEntered, punkIndex []*big.Int, fromAddress []common.Address) (event.Subscription, error) { 1228 1229 var punkIndexRule []interface{} 1230 for _, punkIndexItem := range punkIndex { 1231 punkIndexRule = append(punkIndexRule, punkIndexItem) 1232 } 1233 1234 var fromAddressRule []interface{} 1235 for _, fromAddressItem := range fromAddress { 1236 fromAddressRule = append(fromAddressRule, fromAddressItem) 1237 } 1238 1239 logs, sub, err := _CryptoPunksMarket.contract.WatchLogs(opts, "PunkBidEntered", punkIndexRule, fromAddressRule) 1240 if err != nil { 1241 return nil, err 1242 } 1243 return event.NewSubscription(func(quit <-chan struct{}) error { 1244 defer sub.Unsubscribe() 1245 for { 1246 select { 1247 case log := <-logs: 1248 // New log arrived, parse the event and forward to the user 1249 event := new(CryptoPunksMarketPunkBidEntered) 1250 if err := _CryptoPunksMarket.contract.UnpackLog(event, "PunkBidEntered", log); err != nil { 1251 return err 1252 } 1253 event.Raw = log 1254 1255 select { 1256 case sink <- event: 1257 case err := <-sub.Err(): 1258 return err 1259 case <-quit: 1260 return nil 1261 } 1262 case err := <-sub.Err(): 1263 return err 1264 case <-quit: 1265 return nil 1266 } 1267 } 1268 }), nil 1269 } 1270 1271 // ParsePunkBidEntered is a log parse operation binding the contract event 0x5b859394fabae0c1ba88baffe67e751ab5248d2e879028b8c8d6897b0519f56a. 1272 // 1273 // Solidity: event PunkBidEntered(uint256 indexed punkIndex, uint256 value, address indexed fromAddress) 1274 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) ParsePunkBidEntered(log types.Log) (*CryptoPunksMarketPunkBidEntered, error) { 1275 event := new(CryptoPunksMarketPunkBidEntered) 1276 if err := _CryptoPunksMarket.contract.UnpackLog(event, "PunkBidEntered", log); err != nil { 1277 return nil, err 1278 } 1279 event.Raw = log 1280 return event, nil 1281 } 1282 1283 // CryptoPunksMarketPunkBidWithdrawnIterator is returned from FilterPunkBidWithdrawn and is used to iterate over the raw logs and unpacked data for PunkBidWithdrawn events raised by the CryptoPunksMarket contract. 1284 type CryptoPunksMarketPunkBidWithdrawnIterator struct { 1285 Event *CryptoPunksMarketPunkBidWithdrawn // Event containing the contract specifics and raw log 1286 1287 contract *bind.BoundContract // Generic contract to use for unpacking event data 1288 event string // Event name to use for unpacking event data 1289 1290 logs chan types.Log // Log channel receiving the found contract events 1291 sub ethereum.Subscription // Subscription for errors, completion and termination 1292 done bool // Whether the subscription completed delivering logs 1293 fail error // Occurred error to stop iteration 1294 } 1295 1296 // Next advances the iterator to the subsequent event, returning whether there 1297 // are any more events found. In case of a retrieval or parsing error, false is 1298 // returned and Error() can be queried for the exact failure. 1299 func (it *CryptoPunksMarketPunkBidWithdrawnIterator) Next() bool { 1300 // If the iterator failed, stop iterating 1301 if it.fail != nil { 1302 return false 1303 } 1304 // If the iterator completed, deliver directly whatever's available 1305 if it.done { 1306 select { 1307 case log := <-it.logs: 1308 it.Event = new(CryptoPunksMarketPunkBidWithdrawn) 1309 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1310 it.fail = err 1311 return false 1312 } 1313 it.Event.Raw = log 1314 return true 1315 1316 default: 1317 return false 1318 } 1319 } 1320 // Iterator still in progress, wait for either a data or an error event 1321 select { 1322 case log := <-it.logs: 1323 it.Event = new(CryptoPunksMarketPunkBidWithdrawn) 1324 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1325 it.fail = err 1326 return false 1327 } 1328 it.Event.Raw = log 1329 return true 1330 1331 case err := <-it.sub.Err(): 1332 it.done = true 1333 it.fail = err 1334 return it.Next() 1335 } 1336 } 1337 1338 // Error returns any retrieval or parsing error occurred during filtering. 1339 func (it *CryptoPunksMarketPunkBidWithdrawnIterator) Error() error { 1340 return it.fail 1341 } 1342 1343 // Close terminates the iteration process, releasing any pending underlying 1344 // resources. 1345 func (it *CryptoPunksMarketPunkBidWithdrawnIterator) Close() error { 1346 it.sub.Unsubscribe() 1347 return nil 1348 } 1349 1350 // CryptoPunksMarketPunkBidWithdrawn represents a PunkBidWithdrawn event raised by the CryptoPunksMarket contract. 1351 type CryptoPunksMarketPunkBidWithdrawn struct { 1352 PunkIndex *big.Int 1353 Value *big.Int 1354 FromAddress common.Address 1355 Raw types.Log // Blockchain specific contextual infos 1356 } 1357 1358 // FilterPunkBidWithdrawn is a free log retrieval operation binding the contract event 0x6f30e1ee4d81dcc7a8a478577f65d2ed2edb120565960ac45fe7c50551c87932. 1359 // 1360 // Solidity: event PunkBidWithdrawn(uint256 indexed punkIndex, uint256 value, address indexed fromAddress) 1361 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) FilterPunkBidWithdrawn(opts *bind.FilterOpts, punkIndex []*big.Int, fromAddress []common.Address) (*CryptoPunksMarketPunkBidWithdrawnIterator, error) { 1362 1363 var punkIndexRule []interface{} 1364 for _, punkIndexItem := range punkIndex { 1365 punkIndexRule = append(punkIndexRule, punkIndexItem) 1366 } 1367 1368 var fromAddressRule []interface{} 1369 for _, fromAddressItem := range fromAddress { 1370 fromAddressRule = append(fromAddressRule, fromAddressItem) 1371 } 1372 1373 logs, sub, err := _CryptoPunksMarket.contract.FilterLogs(opts, "PunkBidWithdrawn", punkIndexRule, fromAddressRule) 1374 if err != nil { 1375 return nil, err 1376 } 1377 return &CryptoPunksMarketPunkBidWithdrawnIterator{contract: _CryptoPunksMarket.contract, event: "PunkBidWithdrawn", logs: logs, sub: sub}, nil 1378 } 1379 1380 // WatchPunkBidWithdrawn is a free log subscription operation binding the contract event 0x6f30e1ee4d81dcc7a8a478577f65d2ed2edb120565960ac45fe7c50551c87932. 1381 // 1382 // Solidity: event PunkBidWithdrawn(uint256 indexed punkIndex, uint256 value, address indexed fromAddress) 1383 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) WatchPunkBidWithdrawn(opts *bind.WatchOpts, sink chan<- *CryptoPunksMarketPunkBidWithdrawn, punkIndex []*big.Int, fromAddress []common.Address) (event.Subscription, error) { 1384 1385 var punkIndexRule []interface{} 1386 for _, punkIndexItem := range punkIndex { 1387 punkIndexRule = append(punkIndexRule, punkIndexItem) 1388 } 1389 1390 var fromAddressRule []interface{} 1391 for _, fromAddressItem := range fromAddress { 1392 fromAddressRule = append(fromAddressRule, fromAddressItem) 1393 } 1394 1395 logs, sub, err := _CryptoPunksMarket.contract.WatchLogs(opts, "PunkBidWithdrawn", punkIndexRule, fromAddressRule) 1396 if err != nil { 1397 return nil, err 1398 } 1399 return event.NewSubscription(func(quit <-chan struct{}) error { 1400 defer sub.Unsubscribe() 1401 for { 1402 select { 1403 case log := <-logs: 1404 // New log arrived, parse the event and forward to the user 1405 event := new(CryptoPunksMarketPunkBidWithdrawn) 1406 if err := _CryptoPunksMarket.contract.UnpackLog(event, "PunkBidWithdrawn", log); err != nil { 1407 return err 1408 } 1409 event.Raw = log 1410 1411 select { 1412 case sink <- event: 1413 case err := <-sub.Err(): 1414 return err 1415 case <-quit: 1416 return nil 1417 } 1418 case err := <-sub.Err(): 1419 return err 1420 case <-quit: 1421 return nil 1422 } 1423 } 1424 }), nil 1425 } 1426 1427 // ParsePunkBidWithdrawn is a log parse operation binding the contract event 0x6f30e1ee4d81dcc7a8a478577f65d2ed2edb120565960ac45fe7c50551c87932. 1428 // 1429 // Solidity: event PunkBidWithdrawn(uint256 indexed punkIndex, uint256 value, address indexed fromAddress) 1430 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) ParsePunkBidWithdrawn(log types.Log) (*CryptoPunksMarketPunkBidWithdrawn, error) { 1431 event := new(CryptoPunksMarketPunkBidWithdrawn) 1432 if err := _CryptoPunksMarket.contract.UnpackLog(event, "PunkBidWithdrawn", log); err != nil { 1433 return nil, err 1434 } 1435 event.Raw = log 1436 return event, nil 1437 } 1438 1439 // CryptoPunksMarketPunkBoughtIterator is returned from FilterPunkBought and is used to iterate over the raw logs and unpacked data for PunkBought events raised by the CryptoPunksMarket contract. 1440 type CryptoPunksMarketPunkBoughtIterator struct { 1441 Event *CryptoPunksMarketPunkBought // Event containing the contract specifics and raw log 1442 1443 contract *bind.BoundContract // Generic contract to use for unpacking event data 1444 event string // Event name to use for unpacking event data 1445 1446 logs chan types.Log // Log channel receiving the found contract events 1447 sub ethereum.Subscription // Subscription for errors, completion and termination 1448 done bool // Whether the subscription completed delivering logs 1449 fail error // Occurred error to stop iteration 1450 } 1451 1452 // Next advances the iterator to the subsequent event, returning whether there 1453 // are any more events found. In case of a retrieval or parsing error, false is 1454 // returned and Error() can be queried for the exact failure. 1455 func (it *CryptoPunksMarketPunkBoughtIterator) Next() bool { 1456 // If the iterator failed, stop iterating 1457 if it.fail != nil { 1458 return false 1459 } 1460 // If the iterator completed, deliver directly whatever's available 1461 if it.done { 1462 select { 1463 case log := <-it.logs: 1464 it.Event = new(CryptoPunksMarketPunkBought) 1465 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1466 it.fail = err 1467 return false 1468 } 1469 it.Event.Raw = log 1470 return true 1471 1472 default: 1473 return false 1474 } 1475 } 1476 // Iterator still in progress, wait for either a data or an error event 1477 select { 1478 case log := <-it.logs: 1479 it.Event = new(CryptoPunksMarketPunkBought) 1480 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1481 it.fail = err 1482 return false 1483 } 1484 it.Event.Raw = log 1485 return true 1486 1487 case err := <-it.sub.Err(): 1488 it.done = true 1489 it.fail = err 1490 return it.Next() 1491 } 1492 } 1493 1494 // Error returns any retrieval or parsing error occurred during filtering. 1495 func (it *CryptoPunksMarketPunkBoughtIterator) Error() error { 1496 return it.fail 1497 } 1498 1499 // Close terminates the iteration process, releasing any pending underlying 1500 // resources. 1501 func (it *CryptoPunksMarketPunkBoughtIterator) Close() error { 1502 it.sub.Unsubscribe() 1503 return nil 1504 } 1505 1506 // CryptoPunksMarketPunkBought represents a PunkBought event raised by the CryptoPunksMarket contract. 1507 type CryptoPunksMarketPunkBought struct { 1508 PunkIndex *big.Int 1509 Value *big.Int 1510 FromAddress common.Address 1511 ToAddress common.Address 1512 Raw types.Log // Blockchain specific contextual infos 1513 } 1514 1515 // FilterPunkBought is a free log retrieval operation binding the contract event 0x58e5d5a525e3b40bc15abaa38b5882678db1ee68befd2f60bafe3a7fd06db9e3. 1516 // 1517 // Solidity: event PunkBought(uint256 indexed punkIndex, uint256 value, address indexed fromAddress, address indexed toAddress) 1518 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) FilterPunkBought(opts *bind.FilterOpts, punkIndex []*big.Int, fromAddress []common.Address, toAddress []common.Address) (*CryptoPunksMarketPunkBoughtIterator, error) { 1519 1520 var punkIndexRule []interface{} 1521 for _, punkIndexItem := range punkIndex { 1522 punkIndexRule = append(punkIndexRule, punkIndexItem) 1523 } 1524 1525 var fromAddressRule []interface{} 1526 for _, fromAddressItem := range fromAddress { 1527 fromAddressRule = append(fromAddressRule, fromAddressItem) 1528 } 1529 var toAddressRule []interface{} 1530 for _, toAddressItem := range toAddress { 1531 toAddressRule = append(toAddressRule, toAddressItem) 1532 } 1533 1534 logs, sub, err := _CryptoPunksMarket.contract.FilterLogs(opts, "PunkBought", punkIndexRule, fromAddressRule, toAddressRule) 1535 if err != nil { 1536 return nil, err 1537 } 1538 return &CryptoPunksMarketPunkBoughtIterator{contract: _CryptoPunksMarket.contract, event: "PunkBought", logs: logs, sub: sub}, nil 1539 } 1540 1541 // WatchPunkBought is a free log subscription operation binding the contract event 0x58e5d5a525e3b40bc15abaa38b5882678db1ee68befd2f60bafe3a7fd06db9e3. 1542 // 1543 // Solidity: event PunkBought(uint256 indexed punkIndex, uint256 value, address indexed fromAddress, address indexed toAddress) 1544 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) WatchPunkBought(opts *bind.WatchOpts, sink chan<- *CryptoPunksMarketPunkBought, punkIndex []*big.Int, fromAddress []common.Address, toAddress []common.Address) (event.Subscription, error) { 1545 1546 var punkIndexRule []interface{} 1547 for _, punkIndexItem := range punkIndex { 1548 punkIndexRule = append(punkIndexRule, punkIndexItem) 1549 } 1550 1551 var fromAddressRule []interface{} 1552 for _, fromAddressItem := range fromAddress { 1553 fromAddressRule = append(fromAddressRule, fromAddressItem) 1554 } 1555 var toAddressRule []interface{} 1556 for _, toAddressItem := range toAddress { 1557 toAddressRule = append(toAddressRule, toAddressItem) 1558 } 1559 1560 logs, sub, err := _CryptoPunksMarket.contract.WatchLogs(opts, "PunkBought", punkIndexRule, fromAddressRule, toAddressRule) 1561 if err != nil { 1562 return nil, err 1563 } 1564 return event.NewSubscription(func(quit <-chan struct{}) error { 1565 defer sub.Unsubscribe() 1566 for { 1567 select { 1568 case log := <-logs: 1569 // New log arrived, parse the event and forward to the user 1570 event := new(CryptoPunksMarketPunkBought) 1571 if err := _CryptoPunksMarket.contract.UnpackLog(event, "PunkBought", log); err != nil { 1572 return err 1573 } 1574 event.Raw = log 1575 1576 select { 1577 case sink <- event: 1578 case err := <-sub.Err(): 1579 return err 1580 case <-quit: 1581 return nil 1582 } 1583 case err := <-sub.Err(): 1584 return err 1585 case <-quit: 1586 return nil 1587 } 1588 } 1589 }), nil 1590 } 1591 1592 // ParsePunkBought is a log parse operation binding the contract event 0x58e5d5a525e3b40bc15abaa38b5882678db1ee68befd2f60bafe3a7fd06db9e3. 1593 // 1594 // Solidity: event PunkBought(uint256 indexed punkIndex, uint256 value, address indexed fromAddress, address indexed toAddress) 1595 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) ParsePunkBought(log types.Log) (*CryptoPunksMarketPunkBought, error) { 1596 event := new(CryptoPunksMarketPunkBought) 1597 if err := _CryptoPunksMarket.contract.UnpackLog(event, "PunkBought", log); err != nil { 1598 return nil, err 1599 } 1600 event.Raw = log 1601 return event, nil 1602 } 1603 1604 // CryptoPunksMarketPunkNoLongerForSaleIterator is returned from FilterPunkNoLongerForSale and is used to iterate over the raw logs and unpacked data for PunkNoLongerForSale events raised by the CryptoPunksMarket contract. 1605 type CryptoPunksMarketPunkNoLongerForSaleIterator struct { 1606 Event *CryptoPunksMarketPunkNoLongerForSale // Event containing the contract specifics and raw log 1607 1608 contract *bind.BoundContract // Generic contract to use for unpacking event data 1609 event string // Event name to use for unpacking event data 1610 1611 logs chan types.Log // Log channel receiving the found contract events 1612 sub ethereum.Subscription // Subscription for errors, completion and termination 1613 done bool // Whether the subscription completed delivering logs 1614 fail error // Occurred error to stop iteration 1615 } 1616 1617 // Next advances the iterator to the subsequent event, returning whether there 1618 // are any more events found. In case of a retrieval or parsing error, false is 1619 // returned and Error() can be queried for the exact failure. 1620 func (it *CryptoPunksMarketPunkNoLongerForSaleIterator) Next() bool { 1621 // If the iterator failed, stop iterating 1622 if it.fail != nil { 1623 return false 1624 } 1625 // If the iterator completed, deliver directly whatever's available 1626 if it.done { 1627 select { 1628 case log := <-it.logs: 1629 it.Event = new(CryptoPunksMarketPunkNoLongerForSale) 1630 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1631 it.fail = err 1632 return false 1633 } 1634 it.Event.Raw = log 1635 return true 1636 1637 default: 1638 return false 1639 } 1640 } 1641 // Iterator still in progress, wait for either a data or an error event 1642 select { 1643 case log := <-it.logs: 1644 it.Event = new(CryptoPunksMarketPunkNoLongerForSale) 1645 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1646 it.fail = err 1647 return false 1648 } 1649 it.Event.Raw = log 1650 return true 1651 1652 case err := <-it.sub.Err(): 1653 it.done = true 1654 it.fail = err 1655 return it.Next() 1656 } 1657 } 1658 1659 // Error returns any retrieval or parsing error occurred during filtering. 1660 func (it *CryptoPunksMarketPunkNoLongerForSaleIterator) Error() error { 1661 return it.fail 1662 } 1663 1664 // Close terminates the iteration process, releasing any pending underlying 1665 // resources. 1666 func (it *CryptoPunksMarketPunkNoLongerForSaleIterator) Close() error { 1667 it.sub.Unsubscribe() 1668 return nil 1669 } 1670 1671 // CryptoPunksMarketPunkNoLongerForSale represents a PunkNoLongerForSale event raised by the CryptoPunksMarket contract. 1672 type CryptoPunksMarketPunkNoLongerForSale struct { 1673 PunkIndex *big.Int 1674 Raw types.Log // Blockchain specific contextual infos 1675 } 1676 1677 // FilterPunkNoLongerForSale is a free log retrieval operation binding the contract event 0xb0e0a660b4e50f26f0b7ce75c24655fc76cc66e3334a54ff410277229fa10bd4. 1678 // 1679 // Solidity: event PunkNoLongerForSale(uint256 indexed punkIndex) 1680 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) FilterPunkNoLongerForSale(opts *bind.FilterOpts, punkIndex []*big.Int) (*CryptoPunksMarketPunkNoLongerForSaleIterator, error) { 1681 1682 var punkIndexRule []interface{} 1683 for _, punkIndexItem := range punkIndex { 1684 punkIndexRule = append(punkIndexRule, punkIndexItem) 1685 } 1686 1687 logs, sub, err := _CryptoPunksMarket.contract.FilterLogs(opts, "PunkNoLongerForSale", punkIndexRule) 1688 if err != nil { 1689 return nil, err 1690 } 1691 return &CryptoPunksMarketPunkNoLongerForSaleIterator{contract: _CryptoPunksMarket.contract, event: "PunkNoLongerForSale", logs: logs, sub: sub}, nil 1692 } 1693 1694 // WatchPunkNoLongerForSale is a free log subscription operation binding the contract event 0xb0e0a660b4e50f26f0b7ce75c24655fc76cc66e3334a54ff410277229fa10bd4. 1695 // 1696 // Solidity: event PunkNoLongerForSale(uint256 indexed punkIndex) 1697 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) WatchPunkNoLongerForSale(opts *bind.WatchOpts, sink chan<- *CryptoPunksMarketPunkNoLongerForSale, punkIndex []*big.Int) (event.Subscription, error) { 1698 1699 var punkIndexRule []interface{} 1700 for _, punkIndexItem := range punkIndex { 1701 punkIndexRule = append(punkIndexRule, punkIndexItem) 1702 } 1703 1704 logs, sub, err := _CryptoPunksMarket.contract.WatchLogs(opts, "PunkNoLongerForSale", punkIndexRule) 1705 if err != nil { 1706 return nil, err 1707 } 1708 return event.NewSubscription(func(quit <-chan struct{}) error { 1709 defer sub.Unsubscribe() 1710 for { 1711 select { 1712 case log := <-logs: 1713 // New log arrived, parse the event and forward to the user 1714 event := new(CryptoPunksMarketPunkNoLongerForSale) 1715 if err := _CryptoPunksMarket.contract.UnpackLog(event, "PunkNoLongerForSale", log); err != nil { 1716 return err 1717 } 1718 event.Raw = log 1719 1720 select { 1721 case sink <- event: 1722 case err := <-sub.Err(): 1723 return err 1724 case <-quit: 1725 return nil 1726 } 1727 case err := <-sub.Err(): 1728 return err 1729 case <-quit: 1730 return nil 1731 } 1732 } 1733 }), nil 1734 } 1735 1736 // ParsePunkNoLongerForSale is a log parse operation binding the contract event 0xb0e0a660b4e50f26f0b7ce75c24655fc76cc66e3334a54ff410277229fa10bd4. 1737 // 1738 // Solidity: event PunkNoLongerForSale(uint256 indexed punkIndex) 1739 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) ParsePunkNoLongerForSale(log types.Log) (*CryptoPunksMarketPunkNoLongerForSale, error) { 1740 event := new(CryptoPunksMarketPunkNoLongerForSale) 1741 if err := _CryptoPunksMarket.contract.UnpackLog(event, "PunkNoLongerForSale", log); err != nil { 1742 return nil, err 1743 } 1744 event.Raw = log 1745 return event, nil 1746 } 1747 1748 // CryptoPunksMarketPunkOfferedIterator is returned from FilterPunkOffered and is used to iterate over the raw logs and unpacked data for PunkOffered events raised by the CryptoPunksMarket contract. 1749 type CryptoPunksMarketPunkOfferedIterator struct { 1750 Event *CryptoPunksMarketPunkOffered // Event containing the contract specifics and raw log 1751 1752 contract *bind.BoundContract // Generic contract to use for unpacking event data 1753 event string // Event name to use for unpacking event data 1754 1755 logs chan types.Log // Log channel receiving the found contract events 1756 sub ethereum.Subscription // Subscription for errors, completion and termination 1757 done bool // Whether the subscription completed delivering logs 1758 fail error // Occurred error to stop iteration 1759 } 1760 1761 // Next advances the iterator to the subsequent event, returning whether there 1762 // are any more events found. In case of a retrieval or parsing error, false is 1763 // returned and Error() can be queried for the exact failure. 1764 func (it *CryptoPunksMarketPunkOfferedIterator) Next() bool { 1765 // If the iterator failed, stop iterating 1766 if it.fail != nil { 1767 return false 1768 } 1769 // If the iterator completed, deliver directly whatever's available 1770 if it.done { 1771 select { 1772 case log := <-it.logs: 1773 it.Event = new(CryptoPunksMarketPunkOffered) 1774 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1775 it.fail = err 1776 return false 1777 } 1778 it.Event.Raw = log 1779 return true 1780 1781 default: 1782 return false 1783 } 1784 } 1785 // Iterator still in progress, wait for either a data or an error event 1786 select { 1787 case log := <-it.logs: 1788 it.Event = new(CryptoPunksMarketPunkOffered) 1789 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1790 it.fail = err 1791 return false 1792 } 1793 it.Event.Raw = log 1794 return true 1795 1796 case err := <-it.sub.Err(): 1797 it.done = true 1798 it.fail = err 1799 return it.Next() 1800 } 1801 } 1802 1803 // Error returns any retrieval or parsing error occurred during filtering. 1804 func (it *CryptoPunksMarketPunkOfferedIterator) Error() error { 1805 return it.fail 1806 } 1807 1808 // Close terminates the iteration process, releasing any pending underlying 1809 // resources. 1810 func (it *CryptoPunksMarketPunkOfferedIterator) Close() error { 1811 it.sub.Unsubscribe() 1812 return nil 1813 } 1814 1815 // CryptoPunksMarketPunkOffered represents a PunkOffered event raised by the CryptoPunksMarket contract. 1816 type CryptoPunksMarketPunkOffered struct { 1817 PunkIndex *big.Int 1818 MinValue *big.Int 1819 ToAddress common.Address 1820 Raw types.Log // Blockchain specific contextual infos 1821 } 1822 1823 // FilterPunkOffered is a free log retrieval operation binding the contract event 0x3c7b682d5da98001a9b8cbda6c647d2c63d698a4184fd1d55e2ce7b66f5d21eb. 1824 // 1825 // Solidity: event PunkOffered(uint256 indexed punkIndex, uint256 minValue, address indexed toAddress) 1826 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) FilterPunkOffered(opts *bind.FilterOpts, punkIndex []*big.Int, toAddress []common.Address) (*CryptoPunksMarketPunkOfferedIterator, error) { 1827 1828 var punkIndexRule []interface{} 1829 for _, punkIndexItem := range punkIndex { 1830 punkIndexRule = append(punkIndexRule, punkIndexItem) 1831 } 1832 1833 var toAddressRule []interface{} 1834 for _, toAddressItem := range toAddress { 1835 toAddressRule = append(toAddressRule, toAddressItem) 1836 } 1837 1838 logs, sub, err := _CryptoPunksMarket.contract.FilterLogs(opts, "PunkOffered", punkIndexRule, toAddressRule) 1839 if err != nil { 1840 return nil, err 1841 } 1842 return &CryptoPunksMarketPunkOfferedIterator{contract: _CryptoPunksMarket.contract, event: "PunkOffered", logs: logs, sub: sub}, nil 1843 } 1844 1845 // WatchPunkOffered is a free log subscription operation binding the contract event 0x3c7b682d5da98001a9b8cbda6c647d2c63d698a4184fd1d55e2ce7b66f5d21eb. 1846 // 1847 // Solidity: event PunkOffered(uint256 indexed punkIndex, uint256 minValue, address indexed toAddress) 1848 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) WatchPunkOffered(opts *bind.WatchOpts, sink chan<- *CryptoPunksMarketPunkOffered, punkIndex []*big.Int, toAddress []common.Address) (event.Subscription, error) { 1849 1850 var punkIndexRule []interface{} 1851 for _, punkIndexItem := range punkIndex { 1852 punkIndexRule = append(punkIndexRule, punkIndexItem) 1853 } 1854 1855 var toAddressRule []interface{} 1856 for _, toAddressItem := range toAddress { 1857 toAddressRule = append(toAddressRule, toAddressItem) 1858 } 1859 1860 logs, sub, err := _CryptoPunksMarket.contract.WatchLogs(opts, "PunkOffered", punkIndexRule, toAddressRule) 1861 if err != nil { 1862 return nil, err 1863 } 1864 return event.NewSubscription(func(quit <-chan struct{}) error { 1865 defer sub.Unsubscribe() 1866 for { 1867 select { 1868 case log := <-logs: 1869 // New log arrived, parse the event and forward to the user 1870 event := new(CryptoPunksMarketPunkOffered) 1871 if err := _CryptoPunksMarket.contract.UnpackLog(event, "PunkOffered", log); err != nil { 1872 return err 1873 } 1874 event.Raw = log 1875 1876 select { 1877 case sink <- event: 1878 case err := <-sub.Err(): 1879 return err 1880 case <-quit: 1881 return nil 1882 } 1883 case err := <-sub.Err(): 1884 return err 1885 case <-quit: 1886 return nil 1887 } 1888 } 1889 }), nil 1890 } 1891 1892 // ParsePunkOffered is a log parse operation binding the contract event 0x3c7b682d5da98001a9b8cbda6c647d2c63d698a4184fd1d55e2ce7b66f5d21eb. 1893 // 1894 // Solidity: event PunkOffered(uint256 indexed punkIndex, uint256 minValue, address indexed toAddress) 1895 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) ParsePunkOffered(log types.Log) (*CryptoPunksMarketPunkOffered, error) { 1896 event := new(CryptoPunksMarketPunkOffered) 1897 if err := _CryptoPunksMarket.contract.UnpackLog(event, "PunkOffered", log); err != nil { 1898 return nil, err 1899 } 1900 event.Raw = log 1901 return event, nil 1902 } 1903 1904 // CryptoPunksMarketPunkTransferIterator is returned from FilterPunkTransfer and is used to iterate over the raw logs and unpacked data for PunkTransfer events raised by the CryptoPunksMarket contract. 1905 type CryptoPunksMarketPunkTransferIterator struct { 1906 Event *CryptoPunksMarketPunkTransfer // Event containing the contract specifics and raw log 1907 1908 contract *bind.BoundContract // Generic contract to use for unpacking event data 1909 event string // Event name to use for unpacking event data 1910 1911 logs chan types.Log // Log channel receiving the found contract events 1912 sub ethereum.Subscription // Subscription for errors, completion and termination 1913 done bool // Whether the subscription completed delivering logs 1914 fail error // Occurred error to stop iteration 1915 } 1916 1917 // Next advances the iterator to the subsequent event, returning whether there 1918 // are any more events found. In case of a retrieval or parsing error, false is 1919 // returned and Error() can be queried for the exact failure. 1920 func (it *CryptoPunksMarketPunkTransferIterator) Next() bool { 1921 // If the iterator failed, stop iterating 1922 if it.fail != nil { 1923 return false 1924 } 1925 // If the iterator completed, deliver directly whatever's available 1926 if it.done { 1927 select { 1928 case log := <-it.logs: 1929 it.Event = new(CryptoPunksMarketPunkTransfer) 1930 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1931 it.fail = err 1932 return false 1933 } 1934 it.Event.Raw = log 1935 return true 1936 1937 default: 1938 return false 1939 } 1940 } 1941 // Iterator still in progress, wait for either a data or an error event 1942 select { 1943 case log := <-it.logs: 1944 it.Event = new(CryptoPunksMarketPunkTransfer) 1945 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1946 it.fail = err 1947 return false 1948 } 1949 it.Event.Raw = log 1950 return true 1951 1952 case err := <-it.sub.Err(): 1953 it.done = true 1954 it.fail = err 1955 return it.Next() 1956 } 1957 } 1958 1959 // Error returns any retrieval or parsing error occurred during filtering. 1960 func (it *CryptoPunksMarketPunkTransferIterator) Error() error { 1961 return it.fail 1962 } 1963 1964 // Close terminates the iteration process, releasing any pending underlying 1965 // resources. 1966 func (it *CryptoPunksMarketPunkTransferIterator) Close() error { 1967 it.sub.Unsubscribe() 1968 return nil 1969 } 1970 1971 // CryptoPunksMarketPunkTransfer represents a PunkTransfer event raised by the CryptoPunksMarket contract. 1972 type CryptoPunksMarketPunkTransfer struct { 1973 From common.Address 1974 To common.Address 1975 PunkIndex *big.Int 1976 Raw types.Log // Blockchain specific contextual infos 1977 } 1978 1979 // FilterPunkTransfer is a free log retrieval operation binding the contract event 0x05af636b70da6819000c49f85b21fa82081c632069bb626f30932034099107d8. 1980 // 1981 // Solidity: event PunkTransfer(address indexed from, address indexed to, uint256 punkIndex) 1982 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) FilterPunkTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*CryptoPunksMarketPunkTransferIterator, error) { 1983 1984 var fromRule []interface{} 1985 for _, fromItem := range from { 1986 fromRule = append(fromRule, fromItem) 1987 } 1988 var toRule []interface{} 1989 for _, toItem := range to { 1990 toRule = append(toRule, toItem) 1991 } 1992 1993 logs, sub, err := _CryptoPunksMarket.contract.FilterLogs(opts, "PunkTransfer", fromRule, toRule) 1994 if err != nil { 1995 return nil, err 1996 } 1997 return &CryptoPunksMarketPunkTransferIterator{contract: _CryptoPunksMarket.contract, event: "PunkTransfer", logs: logs, sub: sub}, nil 1998 } 1999 2000 // WatchPunkTransfer is a free log subscription operation binding the contract event 0x05af636b70da6819000c49f85b21fa82081c632069bb626f30932034099107d8. 2001 // 2002 // Solidity: event PunkTransfer(address indexed from, address indexed to, uint256 punkIndex) 2003 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) WatchPunkTransfer(opts *bind.WatchOpts, sink chan<- *CryptoPunksMarketPunkTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { 2004 2005 var fromRule []interface{} 2006 for _, fromItem := range from { 2007 fromRule = append(fromRule, fromItem) 2008 } 2009 var toRule []interface{} 2010 for _, toItem := range to { 2011 toRule = append(toRule, toItem) 2012 } 2013 2014 logs, sub, err := _CryptoPunksMarket.contract.WatchLogs(opts, "PunkTransfer", fromRule, toRule) 2015 if err != nil { 2016 return nil, err 2017 } 2018 return event.NewSubscription(func(quit <-chan struct{}) error { 2019 defer sub.Unsubscribe() 2020 for { 2021 select { 2022 case log := <-logs: 2023 // New log arrived, parse the event and forward to the user 2024 event := new(CryptoPunksMarketPunkTransfer) 2025 if err := _CryptoPunksMarket.contract.UnpackLog(event, "PunkTransfer", log); err != nil { 2026 return err 2027 } 2028 event.Raw = log 2029 2030 select { 2031 case sink <- event: 2032 case err := <-sub.Err(): 2033 return err 2034 case <-quit: 2035 return nil 2036 } 2037 case err := <-sub.Err(): 2038 return err 2039 case <-quit: 2040 return nil 2041 } 2042 } 2043 }), nil 2044 } 2045 2046 // ParsePunkTransfer is a log parse operation binding the contract event 0x05af636b70da6819000c49f85b21fa82081c632069bb626f30932034099107d8. 2047 // 2048 // Solidity: event PunkTransfer(address indexed from, address indexed to, uint256 punkIndex) 2049 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) ParsePunkTransfer(log types.Log) (*CryptoPunksMarketPunkTransfer, error) { 2050 event := new(CryptoPunksMarketPunkTransfer) 2051 if err := _CryptoPunksMarket.contract.UnpackLog(event, "PunkTransfer", log); err != nil { 2052 return nil, err 2053 } 2054 event.Raw = log 2055 return event, nil 2056 } 2057 2058 // CryptoPunksMarketTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the CryptoPunksMarket contract. 2059 type CryptoPunksMarketTransferIterator struct { 2060 Event *CryptoPunksMarketTransfer // Event containing the contract specifics and raw log 2061 2062 contract *bind.BoundContract // Generic contract to use for unpacking event data 2063 event string // Event name to use for unpacking event data 2064 2065 logs chan types.Log // Log channel receiving the found contract events 2066 sub ethereum.Subscription // Subscription for errors, completion and termination 2067 done bool // Whether the subscription completed delivering logs 2068 fail error // Occurred error to stop iteration 2069 } 2070 2071 // Next advances the iterator to the subsequent event, returning whether there 2072 // are any more events found. In case of a retrieval or parsing error, false is 2073 // returned and Error() can be queried for the exact failure. 2074 func (it *CryptoPunksMarketTransferIterator) Next() bool { 2075 // If the iterator failed, stop iterating 2076 if it.fail != nil { 2077 return false 2078 } 2079 // If the iterator completed, deliver directly whatever's available 2080 if it.done { 2081 select { 2082 case log := <-it.logs: 2083 it.Event = new(CryptoPunksMarketTransfer) 2084 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2085 it.fail = err 2086 return false 2087 } 2088 it.Event.Raw = log 2089 return true 2090 2091 default: 2092 return false 2093 } 2094 } 2095 // Iterator still in progress, wait for either a data or an error event 2096 select { 2097 case log := <-it.logs: 2098 it.Event = new(CryptoPunksMarketTransfer) 2099 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2100 it.fail = err 2101 return false 2102 } 2103 it.Event.Raw = log 2104 return true 2105 2106 case err := <-it.sub.Err(): 2107 it.done = true 2108 it.fail = err 2109 return it.Next() 2110 } 2111 } 2112 2113 // Error returns any retrieval or parsing error occurred during filtering. 2114 func (it *CryptoPunksMarketTransferIterator) Error() error { 2115 return it.fail 2116 } 2117 2118 // Close terminates the iteration process, releasing any pending underlying 2119 // resources. 2120 func (it *CryptoPunksMarketTransferIterator) Close() error { 2121 it.sub.Unsubscribe() 2122 return nil 2123 } 2124 2125 // CryptoPunksMarketTransfer represents a Transfer event raised by the CryptoPunksMarket contract. 2126 type CryptoPunksMarketTransfer struct { 2127 From common.Address 2128 To common.Address 2129 Value *big.Int 2130 Raw types.Log // Blockchain specific contextual infos 2131 } 2132 2133 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 2134 // 2135 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 2136 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*CryptoPunksMarketTransferIterator, error) { 2137 2138 var fromRule []interface{} 2139 for _, fromItem := range from { 2140 fromRule = append(fromRule, fromItem) 2141 } 2142 var toRule []interface{} 2143 for _, toItem := range to { 2144 toRule = append(toRule, toItem) 2145 } 2146 2147 logs, sub, err := _CryptoPunksMarket.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 2148 if err != nil { 2149 return nil, err 2150 } 2151 return &CryptoPunksMarketTransferIterator{contract: _CryptoPunksMarket.contract, event: "Transfer", logs: logs, sub: sub}, nil 2152 } 2153 2154 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 2155 // 2156 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 2157 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *CryptoPunksMarketTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { 2158 2159 var fromRule []interface{} 2160 for _, fromItem := range from { 2161 fromRule = append(fromRule, fromItem) 2162 } 2163 var toRule []interface{} 2164 for _, toItem := range to { 2165 toRule = append(toRule, toItem) 2166 } 2167 2168 logs, sub, err := _CryptoPunksMarket.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 2169 if err != nil { 2170 return nil, err 2171 } 2172 return event.NewSubscription(func(quit <-chan struct{}) error { 2173 defer sub.Unsubscribe() 2174 for { 2175 select { 2176 case log := <-logs: 2177 // New log arrived, parse the event and forward to the user 2178 event := new(CryptoPunksMarketTransfer) 2179 if err := _CryptoPunksMarket.contract.UnpackLog(event, "Transfer", log); err != nil { 2180 return err 2181 } 2182 event.Raw = log 2183 2184 select { 2185 case sink <- event: 2186 case err := <-sub.Err(): 2187 return err 2188 case <-quit: 2189 return nil 2190 } 2191 case err := <-sub.Err(): 2192 return err 2193 case <-quit: 2194 return nil 2195 } 2196 } 2197 }), nil 2198 } 2199 2200 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 2201 // 2202 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 2203 func (_CryptoPunksMarket *CryptoPunksMarketFilterer) ParseTransfer(log types.Log) (*CryptoPunksMarketTransfer, error) { 2204 event := new(CryptoPunksMarketTransfer) 2205 if err := _CryptoPunksMarket.contract.UnpackLog(event, "Transfer", log); err != nil { 2206 return nil, err 2207 } 2208 event.Raw = log 2209 return event, nil 2210 }