github.com/kisexp/xdchain@v0.0.0-20211206025815-490d6b732aa7/extension/extensionContracts/contract_extender.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 extensionContracts 5 6 import ( 7 "math/big" 8 "strings" 9 10 ethereum "github.com/kisexp/xdchain" 11 "github.com/kisexp/xdchain/accounts/abi" 12 "github.com/kisexp/xdchain/accounts/abi/bind" 13 "github.com/kisexp/xdchain/common" 14 "github.com/kisexp/xdchain/core/types" 15 "github.com/kisexp/xdchain/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 // ContractExtenderABI is the input ABI used to generate the binding from. 30 const ContractExtenderABI = "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"contractAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipientAddress\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"recipientPTMKey\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"outcome\",\"type\":\"bool\"}],\"name\":\"AllNodesHaveAccepted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"CanPerformStateShare\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"ExtensionFinished\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"toExtend\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"recipientPTMKey\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"recipientAddress\",\"type\":\"address\"}],\"name\":\"NewContractExtensionContractCreated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"vote\",\"type\":\"bool\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"voter\",\"type\":\"address\"}],\"name\":\"NewVote\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"toExtend\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"tesserahash\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"uuid\",\"type\":\"string\"}],\"name\":\"StateShared\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"toExtend\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"uuid\",\"type\":\"string\"}],\"name\":\"UpdateMembers\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[],\"name\":\"checkIfExtensionFinished\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"checkIfVoted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"contractToExtend\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"creator\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"bool\",\"name\":\"vote\",\"type\":\"bool\"},{\"internalType\":\"string\",\"name\":\"nextuuid\",\"type\":\"string\"}],\"name\":\"doVote\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"finish\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"haveAllNodesVoted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"isFinished\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"string\",\"name\":\"hash\",\"type\":\"string\"}],\"name\":\"setSharedStateHash\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"string\",\"name\":\"nextuuid\",\"type\":\"string\"}],\"name\":\"setUuid\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"sharedDataHash\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"targetRecipientPTMKey\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalNumberOfVoters\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"updatePartyMembers\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"voteOutcome\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"votes\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"walletAddressesToVote\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]" 31 32 var ContractExtenderParsedABI, _ = abi.JSON(strings.NewReader(ContractExtenderABI)) 33 34 // ContractExtenderBin is the compiled bytecode used for deploying new contracts. 35 var ContractExtenderBin = "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" 36 37 // DeployContractExtender deploys a new Ethereum contract, binding an instance of ContractExtender to it. 38 func DeployContractExtender(auth *bind.TransactOpts, backend bind.ContractBackend, contractAddress common.Address, recipientAddress common.Address, recipientPTMKey string) (common.Address, *types.Transaction, *ContractExtender, error) { 39 parsed, err := abi.JSON(strings.NewReader(ContractExtenderABI)) 40 if err != nil { 41 return common.Address{}, nil, nil, err 42 } 43 44 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ContractExtenderBin), backend, contractAddress, recipientAddress, recipientPTMKey) 45 if err != nil { 46 return common.Address{}, nil, nil, err 47 } 48 return address, tx, &ContractExtender{ContractExtenderCaller: ContractExtenderCaller{contract: contract}, ContractExtenderTransactor: ContractExtenderTransactor{contract: contract}, ContractExtenderFilterer: ContractExtenderFilterer{contract: contract}}, nil 49 } 50 51 // ContractExtender is an auto generated Go binding around an Ethereum contract. 52 type ContractExtender struct { 53 ContractExtenderCaller // Read-only binding to the contract 54 ContractExtenderTransactor // Write-only binding to the contract 55 ContractExtenderFilterer // Log filterer for contract events 56 } 57 58 // ContractExtenderCaller is an auto generated read-only Go binding around an Ethereum contract. 59 type ContractExtenderCaller struct { 60 contract *bind.BoundContract // Generic contract wrapper for the low level calls 61 } 62 63 // ContractExtenderTransactor is an auto generated write-only Go binding around an Ethereum contract. 64 type ContractExtenderTransactor struct { 65 contract *bind.BoundContract // Generic contract wrapper for the low level calls 66 } 67 68 // ContractExtenderFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 69 type ContractExtenderFilterer struct { 70 contract *bind.BoundContract // Generic contract wrapper for the low level calls 71 } 72 73 // ContractExtenderSession is an auto generated Go binding around an Ethereum contract, 74 // with pre-set call and transact options. 75 type ContractExtenderSession struct { 76 Contract *ContractExtender // Generic contract binding to set the session for 77 CallOpts bind.CallOpts // Call options to use throughout this session 78 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 79 } 80 81 // ContractExtenderCallerSession is an auto generated read-only Go binding around an Ethereum contract, 82 // with pre-set call options. 83 type ContractExtenderCallerSession struct { 84 Contract *ContractExtenderCaller // Generic contract caller binding to set the session for 85 CallOpts bind.CallOpts // Call options to use throughout this session 86 } 87 88 // ContractExtenderTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 89 // with pre-set transact options. 90 type ContractExtenderTransactorSession struct { 91 Contract *ContractExtenderTransactor // Generic contract transactor binding to set the session for 92 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 93 } 94 95 // ContractExtenderRaw is an auto generated low-level Go binding around an Ethereum contract. 96 type ContractExtenderRaw struct { 97 Contract *ContractExtender // Generic contract binding to access the raw methods on 98 } 99 100 // ContractExtenderCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 101 type ContractExtenderCallerRaw struct { 102 Contract *ContractExtenderCaller // Generic read-only contract binding to access the raw methods on 103 } 104 105 // ContractExtenderTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 106 type ContractExtenderTransactorRaw struct { 107 Contract *ContractExtenderTransactor // Generic write-only contract binding to access the raw methods on 108 } 109 110 // NewContractExtender creates a new instance of ContractExtender, bound to a specific deployed contract. 111 func NewContractExtender(address common.Address, backend bind.ContractBackend) (*ContractExtender, error) { 112 contract, err := bindContractExtender(address, backend, backend, backend) 113 if err != nil { 114 return nil, err 115 } 116 return &ContractExtender{ContractExtenderCaller: ContractExtenderCaller{contract: contract}, ContractExtenderTransactor: ContractExtenderTransactor{contract: contract}, ContractExtenderFilterer: ContractExtenderFilterer{contract: contract}}, nil 117 } 118 119 // NewContractExtenderCaller creates a new read-only instance of ContractExtender, bound to a specific deployed contract. 120 func NewContractExtenderCaller(address common.Address, caller bind.ContractCaller) (*ContractExtenderCaller, error) { 121 contract, err := bindContractExtender(address, caller, nil, nil) 122 if err != nil { 123 return nil, err 124 } 125 return &ContractExtenderCaller{contract: contract}, nil 126 } 127 128 // NewContractExtenderTransactor creates a new write-only instance of ContractExtender, bound to a specific deployed contract. 129 func NewContractExtenderTransactor(address common.Address, transactor bind.ContractTransactor) (*ContractExtenderTransactor, error) { 130 contract, err := bindContractExtender(address, nil, transactor, nil) 131 if err != nil { 132 return nil, err 133 } 134 return &ContractExtenderTransactor{contract: contract}, nil 135 } 136 137 // NewContractExtenderFilterer creates a new log filterer instance of ContractExtender, bound to a specific deployed contract. 138 func NewContractExtenderFilterer(address common.Address, filterer bind.ContractFilterer) (*ContractExtenderFilterer, error) { 139 contract, err := bindContractExtender(address, nil, nil, filterer) 140 if err != nil { 141 return nil, err 142 } 143 return &ContractExtenderFilterer{contract: contract}, nil 144 } 145 146 // bindContractExtender binds a generic wrapper to an already deployed contract. 147 func bindContractExtender(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 148 parsed, err := abi.JSON(strings.NewReader(ContractExtenderABI)) 149 if err != nil { 150 return nil, err 151 } 152 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 153 } 154 155 // Call invokes the (constant) contract method with params as input values and 156 // sets the output to result. The result type might be a single field for simple 157 // returns, a slice of interfaces for anonymous returns and a struct for named 158 // returns. 159 func (_ContractExtender *ContractExtenderRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { 160 return _ContractExtender.Contract.ContractExtenderCaller.contract.Call(opts, result, method, params...) 161 } 162 163 // Transfer initiates a plain transaction to move funds to the contract, calling 164 // its default method if one is available. 165 func (_ContractExtender *ContractExtenderRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 166 return _ContractExtender.Contract.ContractExtenderTransactor.contract.Transfer(opts) 167 } 168 169 // Transact invokes the (paid) contract method with params as input values. 170 func (_ContractExtender *ContractExtenderRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 171 return _ContractExtender.Contract.ContractExtenderTransactor.contract.Transact(opts, method, params...) 172 } 173 174 // Call invokes the (constant) contract method with params as input values and 175 // sets the output to result. The result type might be a single field for simple 176 // returns, a slice of interfaces for anonymous returns and a struct for named 177 // returns. 178 func (_ContractExtender *ContractExtenderCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { 179 return _ContractExtender.Contract.contract.Call(opts, result, method, params...) 180 } 181 182 // Transfer initiates a plain transaction to move funds to the contract, calling 183 // its default method if one is available. 184 func (_ContractExtender *ContractExtenderTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 185 return _ContractExtender.Contract.contract.Transfer(opts) 186 } 187 188 // Transact invokes the (paid) contract method with params as input values. 189 func (_ContractExtender *ContractExtenderTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 190 return _ContractExtender.Contract.contract.Transact(opts, method, params...) 191 } 192 193 // CheckIfExtensionFinished is a free data retrieval call binding the contract method 0x1962cb9b. 194 // 195 // Solidity: function checkIfExtensionFinished() view returns(bool) 196 func (_ContractExtender *ContractExtenderCaller) CheckIfExtensionFinished(opts *bind.CallOpts) (bool, error) { 197 var out []interface{} 198 err := _ContractExtender.contract.Call(opts, &out, "checkIfExtensionFinished") 199 200 if err != nil { 201 return *new(bool), err 202 } 203 204 out0 := *abi.ConvertType(out[0], new(bool)).(*bool) 205 206 return out0, err 207 208 } 209 210 // CheckIfExtensionFinished is a free data retrieval call binding the contract method 0x1962cb9b. 211 // 212 // Solidity: function checkIfExtensionFinished() view returns(bool) 213 func (_ContractExtender *ContractExtenderSession) CheckIfExtensionFinished() (bool, error) { 214 return _ContractExtender.Contract.CheckIfExtensionFinished(&_ContractExtender.CallOpts) 215 } 216 217 // CheckIfExtensionFinished is a free data retrieval call binding the contract method 0x1962cb9b. 218 // 219 // Solidity: function checkIfExtensionFinished() view returns(bool) 220 func (_ContractExtender *ContractExtenderCallerSession) CheckIfExtensionFinished() (bool, error) { 221 return _ContractExtender.Contract.CheckIfExtensionFinished(&_ContractExtender.CallOpts) 222 } 223 224 // CheckIfVoted is a free data retrieval call binding the contract method 0xcb2805ec. 225 // 226 // Solidity: function checkIfVoted() view returns(bool) 227 func (_ContractExtender *ContractExtenderCaller) CheckIfVoted(opts *bind.CallOpts) (bool, error) { 228 var out []interface{} 229 err := _ContractExtender.contract.Call(opts, &out, "checkIfVoted") 230 231 if err != nil { 232 return *new(bool), err 233 } 234 235 out0 := *abi.ConvertType(out[0], new(bool)).(*bool) 236 237 return out0, err 238 239 } 240 241 // CheckIfVoted is a free data retrieval call binding the contract method 0xcb2805ec. 242 // 243 // Solidity: function checkIfVoted() view returns(bool) 244 func (_ContractExtender *ContractExtenderSession) CheckIfVoted() (bool, error) { 245 return _ContractExtender.Contract.CheckIfVoted(&_ContractExtender.CallOpts) 246 } 247 248 // CheckIfVoted is a free data retrieval call binding the contract method 0xcb2805ec. 249 // 250 // Solidity: function checkIfVoted() view returns(bool) 251 func (_ContractExtender *ContractExtenderCallerSession) CheckIfVoted() (bool, error) { 252 return _ContractExtender.Contract.CheckIfVoted(&_ContractExtender.CallOpts) 253 } 254 255 // ContractToExtend is a free data retrieval call binding the contract method 0x15e56a6a. 256 // 257 // Solidity: function contractToExtend() view returns(address) 258 func (_ContractExtender *ContractExtenderCaller) ContractToExtend(opts *bind.CallOpts) (common.Address, error) { 259 var out []interface{} 260 err := _ContractExtender.contract.Call(opts, &out, "contractToExtend") 261 262 if err != nil { 263 return *new(common.Address), err 264 } 265 266 out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) 267 268 return out0, err 269 270 } 271 272 // ContractToExtend is a free data retrieval call binding the contract method 0x15e56a6a. 273 // 274 // Solidity: function contractToExtend() view returns(address) 275 func (_ContractExtender *ContractExtenderSession) ContractToExtend() (common.Address, error) { 276 return _ContractExtender.Contract.ContractToExtend(&_ContractExtender.CallOpts) 277 } 278 279 // ContractToExtend is a free data retrieval call binding the contract method 0x15e56a6a. 280 // 281 // Solidity: function contractToExtend() view returns(address) 282 func (_ContractExtender *ContractExtenderCallerSession) ContractToExtend() (common.Address, error) { 283 return _ContractExtender.Contract.ContractToExtend(&_ContractExtender.CallOpts) 284 } 285 286 // Creator is a free data retrieval call binding the contract method 0x02d05d3f. 287 // 288 // Solidity: function creator() view returns(address) 289 func (_ContractExtender *ContractExtenderCaller) Creator(opts *bind.CallOpts) (common.Address, error) { 290 var out []interface{} 291 err := _ContractExtender.contract.Call(opts, &out, "creator") 292 293 if err != nil { 294 return *new(common.Address), err 295 } 296 297 out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) 298 299 return out0, err 300 301 } 302 303 // Creator is a free data retrieval call binding the contract method 0x02d05d3f. 304 // 305 // Solidity: function creator() view returns(address) 306 func (_ContractExtender *ContractExtenderSession) Creator() (common.Address, error) { 307 return _ContractExtender.Contract.Creator(&_ContractExtender.CallOpts) 308 } 309 310 // Creator is a free data retrieval call binding the contract method 0x02d05d3f. 311 // 312 // Solidity: function creator() view returns(address) 313 func (_ContractExtender *ContractExtenderCallerSession) Creator() (common.Address, error) { 314 return _ContractExtender.Contract.Creator(&_ContractExtender.CallOpts) 315 } 316 317 // HaveAllNodesVoted is a free data retrieval call binding the contract method 0xf57077d8. 318 // 319 // Solidity: function haveAllNodesVoted() view returns(bool) 320 func (_ContractExtender *ContractExtenderCaller) HaveAllNodesVoted(opts *bind.CallOpts) (bool, error) { 321 var out []interface{} 322 err := _ContractExtender.contract.Call(opts, &out, "haveAllNodesVoted") 323 324 if err != nil { 325 return *new(bool), err 326 } 327 328 out0 := *abi.ConvertType(out[0], new(bool)).(*bool) 329 330 return out0, err 331 332 } 333 334 // HaveAllNodesVoted is a free data retrieval call binding the contract method 0xf57077d8. 335 // 336 // Solidity: function haveAllNodesVoted() view returns(bool) 337 func (_ContractExtender *ContractExtenderSession) HaveAllNodesVoted() (bool, error) { 338 return _ContractExtender.Contract.HaveAllNodesVoted(&_ContractExtender.CallOpts) 339 } 340 341 // HaveAllNodesVoted is a free data retrieval call binding the contract method 0xf57077d8. 342 // 343 // Solidity: function haveAllNodesVoted() view returns(bool) 344 func (_ContractExtender *ContractExtenderCallerSession) HaveAllNodesVoted() (bool, error) { 345 return _ContractExtender.Contract.HaveAllNodesVoted(&_ContractExtender.CallOpts) 346 } 347 348 // IsFinished is a free data retrieval call binding the contract method 0x7b352962. 349 // 350 // Solidity: function isFinished() view returns(bool) 351 func (_ContractExtender *ContractExtenderCaller) IsFinished(opts *bind.CallOpts) (bool, error) { 352 var out []interface{} 353 err := _ContractExtender.contract.Call(opts, &out, "isFinished") 354 355 if err != nil { 356 return *new(bool), err 357 } 358 359 out0 := *abi.ConvertType(out[0], new(bool)).(*bool) 360 361 return out0, err 362 363 } 364 365 // IsFinished is a free data retrieval call binding the contract method 0x7b352962. 366 // 367 // Solidity: function isFinished() view returns(bool) 368 func (_ContractExtender *ContractExtenderSession) IsFinished() (bool, error) { 369 return _ContractExtender.Contract.IsFinished(&_ContractExtender.CallOpts) 370 } 371 372 // IsFinished is a free data retrieval call binding the contract method 0x7b352962. 373 // 374 // Solidity: function isFinished() view returns(bool) 375 func (_ContractExtender *ContractExtenderCallerSession) IsFinished() (bool, error) { 376 return _ContractExtender.Contract.IsFinished(&_ContractExtender.CallOpts) 377 } 378 379 // SharedDataHash is a free data retrieval call binding the contract method 0x88f520a0. 380 // 381 // Solidity: function sharedDataHash() view returns(string) 382 func (_ContractExtender *ContractExtenderCaller) SharedDataHash(opts *bind.CallOpts) (string, error) { 383 var out []interface{} 384 err := _ContractExtender.contract.Call(opts, &out, "sharedDataHash") 385 386 if err != nil { 387 return *new(string), err 388 } 389 390 out0 := *abi.ConvertType(out[0], new(string)).(*string) 391 392 return out0, err 393 394 } 395 396 // SharedDataHash is a free data retrieval call binding the contract method 0x88f520a0. 397 // 398 // Solidity: function sharedDataHash() view returns(string) 399 func (_ContractExtender *ContractExtenderSession) SharedDataHash() (string, error) { 400 return _ContractExtender.Contract.SharedDataHash(&_ContractExtender.CallOpts) 401 } 402 403 // SharedDataHash is a free data retrieval call binding the contract method 0x88f520a0. 404 // 405 // Solidity: function sharedDataHash() view returns(string) 406 func (_ContractExtender *ContractExtenderCallerSession) SharedDataHash() (string, error) { 407 return _ContractExtender.Contract.SharedDataHash(&_ContractExtender.CallOpts) 408 } 409 410 // TargetRecipientPTMKey is a free data retrieval call binding the contract method 0xe5af0f30. 411 // 412 // Solidity: function targetRecipientPTMKey() view returns(string) 413 func (_ContractExtender *ContractExtenderCaller) TargetRecipientPTMKey(opts *bind.CallOpts) (string, error) { 414 var out []interface{} 415 err := _ContractExtender.contract.Call(opts, &out, "targetRecipientPTMKey") 416 417 if err != nil { 418 return *new(string), err 419 } 420 421 out0 := *abi.ConvertType(out[0], new(string)).(*string) 422 423 return out0, err 424 425 } 426 427 // TargetRecipientPTMKey is a free data retrieval call binding the contract method 0xe5af0f30. 428 // 429 // Solidity: function targetRecipientPTMKey() view returns(string) 430 func (_ContractExtender *ContractExtenderSession) TargetRecipientPTMKey() (string, error) { 431 return _ContractExtender.Contract.TargetRecipientPTMKey(&_ContractExtender.CallOpts) 432 } 433 434 // TargetRecipientPTMKey is a free data retrieval call binding the contract method 0xe5af0f30. 435 // 436 // Solidity: function targetRecipientPTMKey() view returns(string) 437 func (_ContractExtender *ContractExtenderCallerSession) TargetRecipientPTMKey() (string, error) { 438 return _ContractExtender.Contract.TargetRecipientPTMKey(&_ContractExtender.CallOpts) 439 } 440 441 // TotalNumberOfVoters is a free data retrieval call binding the contract method 0x38527727. 442 // 443 // Solidity: function totalNumberOfVoters() view returns(uint256) 444 func (_ContractExtender *ContractExtenderCaller) TotalNumberOfVoters(opts *bind.CallOpts) (*big.Int, error) { 445 var out []interface{} 446 err := _ContractExtender.contract.Call(opts, &out, "totalNumberOfVoters") 447 448 if err != nil { 449 return *new(*big.Int), err 450 } 451 452 out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) 453 454 return out0, err 455 456 } 457 458 // TotalNumberOfVoters is a free data retrieval call binding the contract method 0x38527727. 459 // 460 // Solidity: function totalNumberOfVoters() view returns(uint256) 461 func (_ContractExtender *ContractExtenderSession) TotalNumberOfVoters() (*big.Int, error) { 462 return _ContractExtender.Contract.TotalNumberOfVoters(&_ContractExtender.CallOpts) 463 } 464 465 // TotalNumberOfVoters is a free data retrieval call binding the contract method 0x38527727. 466 // 467 // Solidity: function totalNumberOfVoters() view returns(uint256) 468 func (_ContractExtender *ContractExtenderCallerSession) TotalNumberOfVoters() (*big.Int, error) { 469 return _ContractExtender.Contract.TotalNumberOfVoters(&_ContractExtender.CallOpts) 470 } 471 472 // VoteOutcome is a free data retrieval call binding the contract method 0xb5da45bb. 473 // 474 // Solidity: function voteOutcome() view returns(bool) 475 func (_ContractExtender *ContractExtenderCaller) VoteOutcome(opts *bind.CallOpts) (bool, error) { 476 var out []interface{} 477 err := _ContractExtender.contract.Call(opts, &out, "voteOutcome") 478 479 if err != nil { 480 return *new(bool), err 481 } 482 483 out0 := *abi.ConvertType(out[0], new(bool)).(*bool) 484 485 return out0, err 486 487 } 488 489 // VoteOutcome is a free data retrieval call binding the contract method 0xb5da45bb. 490 // 491 // Solidity: function voteOutcome() view returns(bool) 492 func (_ContractExtender *ContractExtenderSession) VoteOutcome() (bool, error) { 493 return _ContractExtender.Contract.VoteOutcome(&_ContractExtender.CallOpts) 494 } 495 496 // VoteOutcome is a free data retrieval call binding the contract method 0xb5da45bb. 497 // 498 // Solidity: function voteOutcome() view returns(bool) 499 func (_ContractExtender *ContractExtenderCallerSession) VoteOutcome() (bool, error) { 500 return _ContractExtender.Contract.VoteOutcome(&_ContractExtender.CallOpts) 501 } 502 503 // Votes is a free data retrieval call binding the contract method 0xd8bff5a5. 504 // 505 // Solidity: function votes(address ) view returns(bool) 506 func (_ContractExtender *ContractExtenderCaller) Votes(opts *bind.CallOpts, arg0 common.Address) (bool, error) { 507 var out []interface{} 508 err := _ContractExtender.contract.Call(opts, &out, "votes", arg0) 509 510 if err != nil { 511 return *new(bool), err 512 } 513 514 out0 := *abi.ConvertType(out[0], new(bool)).(*bool) 515 516 return out0, err 517 518 } 519 520 // Votes is a free data retrieval call binding the contract method 0xd8bff5a5. 521 // 522 // Solidity: function votes(address ) view returns(bool) 523 func (_ContractExtender *ContractExtenderSession) Votes(arg0 common.Address) (bool, error) { 524 return _ContractExtender.Contract.Votes(&_ContractExtender.CallOpts, arg0) 525 } 526 527 // Votes is a free data retrieval call binding the contract method 0xd8bff5a5. 528 // 529 // Solidity: function votes(address ) view returns(bool) 530 func (_ContractExtender *ContractExtenderCallerSession) Votes(arg0 common.Address) (bool, error) { 531 return _ContractExtender.Contract.Votes(&_ContractExtender.CallOpts, arg0) 532 } 533 534 // WalletAddressesToVote is a free data retrieval call binding the contract method 0x79d41b8f. 535 // 536 // Solidity: function walletAddressesToVote(uint256 ) view returns(address) 537 func (_ContractExtender *ContractExtenderCaller) WalletAddressesToVote(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error) { 538 var out []interface{} 539 err := _ContractExtender.contract.Call(opts, &out, "walletAddressesToVote", arg0) 540 541 if err != nil { 542 return *new(common.Address), err 543 } 544 545 out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) 546 547 return out0, err 548 549 } 550 551 // WalletAddressesToVote is a free data retrieval call binding the contract method 0x79d41b8f. 552 // 553 // Solidity: function walletAddressesToVote(uint256 ) view returns(address) 554 func (_ContractExtender *ContractExtenderSession) WalletAddressesToVote(arg0 *big.Int) (common.Address, error) { 555 return _ContractExtender.Contract.WalletAddressesToVote(&_ContractExtender.CallOpts, arg0) 556 } 557 558 // WalletAddressesToVote is a free data retrieval call binding the contract method 0x79d41b8f. 559 // 560 // Solidity: function walletAddressesToVote(uint256 ) view returns(address) 561 func (_ContractExtender *ContractExtenderCallerSession) WalletAddressesToVote(arg0 *big.Int) (common.Address, error) { 562 return _ContractExtender.Contract.WalletAddressesToVote(&_ContractExtender.CallOpts, arg0) 563 } 564 565 // DoVote is a paid mutator transaction binding the contract method 0xde5828cb. 566 // 567 // Solidity: function doVote(bool vote, string nextuuid) returns() 568 func (_ContractExtender *ContractExtenderTransactor) DoVote(opts *bind.TransactOpts, vote bool, nextuuid string) (*types.Transaction, error) { 569 return _ContractExtender.contract.Transact(opts, "doVote", vote, nextuuid) 570 } 571 572 // DoVote is a paid mutator transaction binding the contract method 0xde5828cb. 573 // 574 // Solidity: function doVote(bool vote, string nextuuid) returns() 575 func (_ContractExtender *ContractExtenderSession) DoVote(vote bool, nextuuid string) (*types.Transaction, error) { 576 return _ContractExtender.Contract.DoVote(&_ContractExtender.TransactOpts, vote, nextuuid) 577 } 578 579 // DoVote is a paid mutator transaction binding the contract method 0xde5828cb. 580 // 581 // Solidity: function doVote(bool vote, string nextuuid) returns() 582 func (_ContractExtender *ContractExtenderTransactorSession) DoVote(vote bool, nextuuid string) (*types.Transaction, error) { 583 return _ContractExtender.Contract.DoVote(&_ContractExtender.TransactOpts, vote, nextuuid) 584 } 585 586 // Finish is a paid mutator transaction binding the contract method 0xd56b2889. 587 // 588 // Solidity: function finish() returns() 589 func (_ContractExtender *ContractExtenderTransactor) Finish(opts *bind.TransactOpts) (*types.Transaction, error) { 590 return _ContractExtender.contract.Transact(opts, "finish") 591 } 592 593 // Finish is a paid mutator transaction binding the contract method 0xd56b2889. 594 // 595 // Solidity: function finish() returns() 596 func (_ContractExtender *ContractExtenderSession) Finish() (*types.Transaction, error) { 597 return _ContractExtender.Contract.Finish(&_ContractExtender.TransactOpts) 598 } 599 600 // Finish is a paid mutator transaction binding the contract method 0xd56b2889. 601 // 602 // Solidity: function finish() returns() 603 func (_ContractExtender *ContractExtenderTransactorSession) Finish() (*types.Transaction, error) { 604 return _ContractExtender.Contract.Finish(&_ContractExtender.TransactOpts) 605 } 606 607 // SetSharedStateHash is a paid mutator transaction binding the contract method 0x893971ba. 608 // 609 // Solidity: function setSharedStateHash(string hash) returns() 610 func (_ContractExtender *ContractExtenderTransactor) SetSharedStateHash(opts *bind.TransactOpts, hash string) (*types.Transaction, error) { 611 return _ContractExtender.contract.Transact(opts, "setSharedStateHash", hash) 612 } 613 614 // SetSharedStateHash is a paid mutator transaction binding the contract method 0x893971ba. 615 // 616 // Solidity: function setSharedStateHash(string hash) returns() 617 func (_ContractExtender *ContractExtenderSession) SetSharedStateHash(hash string) (*types.Transaction, error) { 618 return _ContractExtender.Contract.SetSharedStateHash(&_ContractExtender.TransactOpts, hash) 619 } 620 621 // SetSharedStateHash is a paid mutator transaction binding the contract method 0x893971ba. 622 // 623 // Solidity: function setSharedStateHash(string hash) returns() 624 func (_ContractExtender *ContractExtenderTransactorSession) SetSharedStateHash(hash string) (*types.Transaction, error) { 625 return _ContractExtender.Contract.SetSharedStateHash(&_ContractExtender.TransactOpts, hash) 626 } 627 628 // SetUuid is a paid mutator transaction binding the contract method 0x821e93da. 629 // 630 // Solidity: function setUuid(string nextuuid) returns() 631 func (_ContractExtender *ContractExtenderTransactor) SetUuid(opts *bind.TransactOpts, nextuuid string) (*types.Transaction, error) { 632 return _ContractExtender.contract.Transact(opts, "setUuid", nextuuid) 633 } 634 635 // SetUuid is a paid mutator transaction binding the contract method 0x821e93da. 636 // 637 // Solidity: function setUuid(string nextuuid) returns() 638 func (_ContractExtender *ContractExtenderSession) SetUuid(nextuuid string) (*types.Transaction, error) { 639 return _ContractExtender.Contract.SetUuid(&_ContractExtender.TransactOpts, nextuuid) 640 } 641 642 // SetUuid is a paid mutator transaction binding the contract method 0x821e93da. 643 // 644 // Solidity: function setUuid(string nextuuid) returns() 645 func (_ContractExtender *ContractExtenderTransactorSession) SetUuid(nextuuid string) (*types.Transaction, error) { 646 return _ContractExtender.Contract.SetUuid(&_ContractExtender.TransactOpts, nextuuid) 647 } 648 649 // UpdatePartyMembers is a paid mutator transaction binding the contract method 0xac8b9205. 650 // 651 // Solidity: function updatePartyMembers() returns() 652 func (_ContractExtender *ContractExtenderTransactor) UpdatePartyMembers(opts *bind.TransactOpts) (*types.Transaction, error) { 653 return _ContractExtender.contract.Transact(opts, "updatePartyMembers") 654 } 655 656 // UpdatePartyMembers is a paid mutator transaction binding the contract method 0xac8b9205. 657 // 658 // Solidity: function updatePartyMembers() returns() 659 func (_ContractExtender *ContractExtenderSession) UpdatePartyMembers() (*types.Transaction, error) { 660 return _ContractExtender.Contract.UpdatePartyMembers(&_ContractExtender.TransactOpts) 661 } 662 663 // UpdatePartyMembers is a paid mutator transaction binding the contract method 0xac8b9205. 664 // 665 // Solidity: function updatePartyMembers() returns() 666 func (_ContractExtender *ContractExtenderTransactorSession) UpdatePartyMembers() (*types.Transaction, error) { 667 return _ContractExtender.Contract.UpdatePartyMembers(&_ContractExtender.TransactOpts) 668 } 669 670 // ContractExtenderAllNodesHaveAcceptedIterator is returned from FilterAllNodesHaveAccepted and is used to iterate over the raw logs and unpacked data for AllNodesHaveAccepted events raised by the ContractExtender contract. 671 type ContractExtenderAllNodesHaveAcceptedIterator struct { 672 Event *ContractExtenderAllNodesHaveAccepted // Event containing the contract specifics and raw log 673 674 contract *bind.BoundContract // Generic contract to use for unpacking event data 675 event string // Event name to use for unpacking event data 676 677 logs chan types.Log // Log channel receiving the found contract events 678 sub ethereum.Subscription // Subscription for errors, completion and termination 679 done bool // Whether the subscription completed delivering logs 680 fail error // Occurred error to stop iteration 681 } 682 683 // Next advances the iterator to the subsequent event, returning whether there 684 // are any more events found. In case of a retrieval or parsing error, false is 685 // returned and Error() can be queried for the exact failure. 686 func (it *ContractExtenderAllNodesHaveAcceptedIterator) Next() bool { 687 // If the iterator failed, stop iterating 688 if it.fail != nil { 689 return false 690 } 691 // If the iterator completed, deliver directly whatever's available 692 if it.done { 693 select { 694 case log := <-it.logs: 695 it.Event = new(ContractExtenderAllNodesHaveAccepted) 696 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 697 it.fail = err 698 return false 699 } 700 it.Event.Raw = log 701 return true 702 703 default: 704 return false 705 } 706 } 707 // Iterator still in progress, wait for either a data or an error event 708 select { 709 case log := <-it.logs: 710 it.Event = new(ContractExtenderAllNodesHaveAccepted) 711 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 712 it.fail = err 713 return false 714 } 715 it.Event.Raw = log 716 return true 717 718 case err := <-it.sub.Err(): 719 it.done = true 720 it.fail = err 721 return it.Next() 722 } 723 } 724 725 // Error returns any retrieval or parsing error occurred during filtering. 726 func (it *ContractExtenderAllNodesHaveAcceptedIterator) Error() error { 727 return it.fail 728 } 729 730 // Close terminates the iteration process, releasing any pending underlying 731 // resources. 732 func (it *ContractExtenderAllNodesHaveAcceptedIterator) Close() error { 733 it.sub.Unsubscribe() 734 return nil 735 } 736 737 // ContractExtenderAllNodesHaveAccepted represents a AllNodesHaveAccepted event raised by the ContractExtender contract. 738 type ContractExtenderAllNodesHaveAccepted struct { 739 Outcome bool 740 Raw types.Log // Blockchain specific contextual infos 741 } 742 743 // FilterAllNodesHaveAccepted is a free log retrieval operation binding the contract event 0xf20540914db019dd7c8d05ed165316a58d1583642772ac46f3d0c29b8644bd36. 744 // 745 // Solidity: event AllNodesHaveAccepted(bool outcome) 746 func (_ContractExtender *ContractExtenderFilterer) FilterAllNodesHaveAccepted(opts *bind.FilterOpts) (*ContractExtenderAllNodesHaveAcceptedIterator, error) { 747 748 logs, sub, err := _ContractExtender.contract.FilterLogs(opts, "AllNodesHaveAccepted") 749 if err != nil { 750 return nil, err 751 } 752 return &ContractExtenderAllNodesHaveAcceptedIterator{contract: _ContractExtender.contract, event: "AllNodesHaveAccepted", logs: logs, sub: sub}, nil 753 } 754 755 var AllNodesHaveAcceptedTopicHash = "0xf20540914db019dd7c8d05ed165316a58d1583642772ac46f3d0c29b8644bd36" 756 757 // WatchAllNodesHaveAccepted is a free log subscription operation binding the contract event 0xf20540914db019dd7c8d05ed165316a58d1583642772ac46f3d0c29b8644bd36. 758 // 759 // Solidity: event AllNodesHaveAccepted(bool outcome) 760 func (_ContractExtender *ContractExtenderFilterer) WatchAllNodesHaveAccepted(opts *bind.WatchOpts, sink chan<- *ContractExtenderAllNodesHaveAccepted) (event.Subscription, error) { 761 762 logs, sub, err := _ContractExtender.contract.WatchLogs(opts, "AllNodesHaveAccepted") 763 if err != nil { 764 return nil, err 765 } 766 return event.NewSubscription(func(quit <-chan struct{}) error { 767 defer sub.Unsubscribe() 768 for { 769 select { 770 case log := <-logs: 771 // New log arrived, parse the event and forward to the user 772 event := new(ContractExtenderAllNodesHaveAccepted) 773 if err := _ContractExtender.contract.UnpackLog(event, "AllNodesHaveAccepted", log); err != nil { 774 return err 775 } 776 event.Raw = log 777 778 select { 779 case sink <- event: 780 case err := <-sub.Err(): 781 return err 782 case <-quit: 783 return nil 784 } 785 case err := <-sub.Err(): 786 return err 787 case <-quit: 788 return nil 789 } 790 } 791 }), nil 792 } 793 794 // ParseAllNodesHaveAccepted is a log parse operation binding the contract event 0xf20540914db019dd7c8d05ed165316a58d1583642772ac46f3d0c29b8644bd36. 795 // 796 // Solidity: event AllNodesHaveAccepted(bool outcome) 797 func (_ContractExtender *ContractExtenderFilterer) ParseAllNodesHaveAccepted(log types.Log) (*ContractExtenderAllNodesHaveAccepted, error) { 798 event := new(ContractExtenderAllNodesHaveAccepted) 799 if err := _ContractExtender.contract.UnpackLog(event, "AllNodesHaveAccepted", log); err != nil { 800 return nil, err 801 } 802 return event, nil 803 } 804 805 // ContractExtenderCanPerformStateShareIterator is returned from FilterCanPerformStateShare and is used to iterate over the raw logs and unpacked data for CanPerformStateShare events raised by the ContractExtender contract. 806 type ContractExtenderCanPerformStateShareIterator struct { 807 Event *ContractExtenderCanPerformStateShare // Event containing the contract specifics and raw log 808 809 contract *bind.BoundContract // Generic contract to use for unpacking event data 810 event string // Event name to use for unpacking event data 811 812 logs chan types.Log // Log channel receiving the found contract events 813 sub ethereum.Subscription // Subscription for errors, completion and termination 814 done bool // Whether the subscription completed delivering logs 815 fail error // Occurred error to stop iteration 816 } 817 818 // Next advances the iterator to the subsequent event, returning whether there 819 // are any more events found. In case of a retrieval or parsing error, false is 820 // returned and Error() can be queried for the exact failure. 821 func (it *ContractExtenderCanPerformStateShareIterator) Next() bool { 822 // If the iterator failed, stop iterating 823 if it.fail != nil { 824 return false 825 } 826 // If the iterator completed, deliver directly whatever's available 827 if it.done { 828 select { 829 case log := <-it.logs: 830 it.Event = new(ContractExtenderCanPerformStateShare) 831 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 832 it.fail = err 833 return false 834 } 835 it.Event.Raw = log 836 return true 837 838 default: 839 return false 840 } 841 } 842 // Iterator still in progress, wait for either a data or an error event 843 select { 844 case log := <-it.logs: 845 it.Event = new(ContractExtenderCanPerformStateShare) 846 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 847 it.fail = err 848 return false 849 } 850 it.Event.Raw = log 851 return true 852 853 case err := <-it.sub.Err(): 854 it.done = true 855 it.fail = err 856 return it.Next() 857 } 858 } 859 860 // Error returns any retrieval or parsing error occurred during filtering. 861 func (it *ContractExtenderCanPerformStateShareIterator) Error() error { 862 return it.fail 863 } 864 865 // Close terminates the iteration process, releasing any pending underlying 866 // resources. 867 func (it *ContractExtenderCanPerformStateShareIterator) Close() error { 868 it.sub.Unsubscribe() 869 return nil 870 } 871 872 // ContractExtenderCanPerformStateShare represents a CanPerformStateShare event raised by the ContractExtender contract. 873 type ContractExtenderCanPerformStateShare struct { 874 Raw types.Log // Blockchain specific contextual infos 875 } 876 877 // FilterCanPerformStateShare is a free log retrieval operation binding the contract event 0xfd46cafaa71d87561071b8095703a7f081265fad232945049f5cf2d2c39b3d28. 878 // 879 // Solidity: event CanPerformStateShare() 880 func (_ContractExtender *ContractExtenderFilterer) FilterCanPerformStateShare(opts *bind.FilterOpts) (*ContractExtenderCanPerformStateShareIterator, error) { 881 882 logs, sub, err := _ContractExtender.contract.FilterLogs(opts, "CanPerformStateShare") 883 if err != nil { 884 return nil, err 885 } 886 return &ContractExtenderCanPerformStateShareIterator{contract: _ContractExtender.contract, event: "CanPerformStateShare", logs: logs, sub: sub}, nil 887 } 888 889 var CanPerformStateShareTopicHash = "0xfd46cafaa71d87561071b8095703a7f081265fad232945049f5cf2d2c39b3d28" 890 891 // WatchCanPerformStateShare is a free log subscription operation binding the contract event 0xfd46cafaa71d87561071b8095703a7f081265fad232945049f5cf2d2c39b3d28. 892 // 893 // Solidity: event CanPerformStateShare() 894 func (_ContractExtender *ContractExtenderFilterer) WatchCanPerformStateShare(opts *bind.WatchOpts, sink chan<- *ContractExtenderCanPerformStateShare) (event.Subscription, error) { 895 896 logs, sub, err := _ContractExtender.contract.WatchLogs(opts, "CanPerformStateShare") 897 if err != nil { 898 return nil, err 899 } 900 return event.NewSubscription(func(quit <-chan struct{}) error { 901 defer sub.Unsubscribe() 902 for { 903 select { 904 case log := <-logs: 905 // New log arrived, parse the event and forward to the user 906 event := new(ContractExtenderCanPerformStateShare) 907 if err := _ContractExtender.contract.UnpackLog(event, "CanPerformStateShare", log); err != nil { 908 return err 909 } 910 event.Raw = log 911 912 select { 913 case sink <- event: 914 case err := <-sub.Err(): 915 return err 916 case <-quit: 917 return nil 918 } 919 case err := <-sub.Err(): 920 return err 921 case <-quit: 922 return nil 923 } 924 } 925 }), nil 926 } 927 928 // ParseCanPerformStateShare is a log parse operation binding the contract event 0xfd46cafaa71d87561071b8095703a7f081265fad232945049f5cf2d2c39b3d28. 929 // 930 // Solidity: event CanPerformStateShare() 931 func (_ContractExtender *ContractExtenderFilterer) ParseCanPerformStateShare(log types.Log) (*ContractExtenderCanPerformStateShare, error) { 932 event := new(ContractExtenderCanPerformStateShare) 933 if err := _ContractExtender.contract.UnpackLog(event, "CanPerformStateShare", log); err != nil { 934 return nil, err 935 } 936 return event, nil 937 } 938 939 // ContractExtenderExtensionFinishedIterator is returned from FilterExtensionFinished and is used to iterate over the raw logs and unpacked data for ExtensionFinished events raised by the ContractExtender contract. 940 type ContractExtenderExtensionFinishedIterator struct { 941 Event *ContractExtenderExtensionFinished // Event containing the contract specifics and raw log 942 943 contract *bind.BoundContract // Generic contract to use for unpacking event data 944 event string // Event name to use for unpacking event data 945 946 logs chan types.Log // Log channel receiving the found contract events 947 sub ethereum.Subscription // Subscription for errors, completion and termination 948 done bool // Whether the subscription completed delivering logs 949 fail error // Occurred error to stop iteration 950 } 951 952 // Next advances the iterator to the subsequent event, returning whether there 953 // are any more events found. In case of a retrieval or parsing error, false is 954 // returned and Error() can be queried for the exact failure. 955 func (it *ContractExtenderExtensionFinishedIterator) Next() bool { 956 // If the iterator failed, stop iterating 957 if it.fail != nil { 958 return false 959 } 960 // If the iterator completed, deliver directly whatever's available 961 if it.done { 962 select { 963 case log := <-it.logs: 964 it.Event = new(ContractExtenderExtensionFinished) 965 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 966 it.fail = err 967 return false 968 } 969 it.Event.Raw = log 970 return true 971 972 default: 973 return false 974 } 975 } 976 // Iterator still in progress, wait for either a data or an error event 977 select { 978 case log := <-it.logs: 979 it.Event = new(ContractExtenderExtensionFinished) 980 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 981 it.fail = err 982 return false 983 } 984 it.Event.Raw = log 985 return true 986 987 case err := <-it.sub.Err(): 988 it.done = true 989 it.fail = err 990 return it.Next() 991 } 992 } 993 994 // Error returns any retrieval or parsing error occurred during filtering. 995 func (it *ContractExtenderExtensionFinishedIterator) Error() error { 996 return it.fail 997 } 998 999 // Close terminates the iteration process, releasing any pending underlying 1000 // resources. 1001 func (it *ContractExtenderExtensionFinishedIterator) Close() error { 1002 it.sub.Unsubscribe() 1003 return nil 1004 } 1005 1006 // ContractExtenderExtensionFinished represents a ExtensionFinished event raised by the ContractExtender contract. 1007 type ContractExtenderExtensionFinished struct { 1008 Raw types.Log // Blockchain specific contextual infos 1009 } 1010 1011 // FilterExtensionFinished is a free log retrieval operation binding the contract event 0x79c47b570b18a8a814b785800e5fcbf104e067663589cef1bba07756e3c6ede9. 1012 // 1013 // Solidity: event ExtensionFinished() 1014 func (_ContractExtender *ContractExtenderFilterer) FilterExtensionFinished(opts *bind.FilterOpts) (*ContractExtenderExtensionFinishedIterator, error) { 1015 1016 logs, sub, err := _ContractExtender.contract.FilterLogs(opts, "ExtensionFinished") 1017 if err != nil { 1018 return nil, err 1019 } 1020 return &ContractExtenderExtensionFinishedIterator{contract: _ContractExtender.contract, event: "ExtensionFinished", logs: logs, sub: sub}, nil 1021 } 1022 1023 var ExtensionFinishedTopicHash = "0x79c47b570b18a8a814b785800e5fcbf104e067663589cef1bba07756e3c6ede9" 1024 1025 // WatchExtensionFinished is a free log subscription operation binding the contract event 0x79c47b570b18a8a814b785800e5fcbf104e067663589cef1bba07756e3c6ede9. 1026 // 1027 // Solidity: event ExtensionFinished() 1028 func (_ContractExtender *ContractExtenderFilterer) WatchExtensionFinished(opts *bind.WatchOpts, sink chan<- *ContractExtenderExtensionFinished) (event.Subscription, error) { 1029 1030 logs, sub, err := _ContractExtender.contract.WatchLogs(opts, "ExtensionFinished") 1031 if err != nil { 1032 return nil, err 1033 } 1034 return event.NewSubscription(func(quit <-chan struct{}) error { 1035 defer sub.Unsubscribe() 1036 for { 1037 select { 1038 case log := <-logs: 1039 // New log arrived, parse the event and forward to the user 1040 event := new(ContractExtenderExtensionFinished) 1041 if err := _ContractExtender.contract.UnpackLog(event, "ExtensionFinished", log); err != nil { 1042 return err 1043 } 1044 event.Raw = log 1045 1046 select { 1047 case sink <- event: 1048 case err := <-sub.Err(): 1049 return err 1050 case <-quit: 1051 return nil 1052 } 1053 case err := <-sub.Err(): 1054 return err 1055 case <-quit: 1056 return nil 1057 } 1058 } 1059 }), nil 1060 } 1061 1062 // ParseExtensionFinished is a log parse operation binding the contract event 0x79c47b570b18a8a814b785800e5fcbf104e067663589cef1bba07756e3c6ede9. 1063 // 1064 // Solidity: event ExtensionFinished() 1065 func (_ContractExtender *ContractExtenderFilterer) ParseExtensionFinished(log types.Log) (*ContractExtenderExtensionFinished, error) { 1066 event := new(ContractExtenderExtensionFinished) 1067 if err := _ContractExtender.contract.UnpackLog(event, "ExtensionFinished", log); err != nil { 1068 return nil, err 1069 } 1070 return event, nil 1071 } 1072 1073 // ContractExtenderNewContractExtensionContractCreatedIterator is returned from FilterNewContractExtensionContractCreated and is used to iterate over the raw logs and unpacked data for NewContractExtensionContractCreated events raised by the ContractExtender contract. 1074 type ContractExtenderNewContractExtensionContractCreatedIterator struct { 1075 Event *ContractExtenderNewContractExtensionContractCreated // Event containing the contract specifics and raw log 1076 1077 contract *bind.BoundContract // Generic contract to use for unpacking event data 1078 event string // Event name to use for unpacking event data 1079 1080 logs chan types.Log // Log channel receiving the found contract events 1081 sub ethereum.Subscription // Subscription for errors, completion and termination 1082 done bool // Whether the subscription completed delivering logs 1083 fail error // Occurred error to stop iteration 1084 } 1085 1086 // Next advances the iterator to the subsequent event, returning whether there 1087 // are any more events found. In case of a retrieval or parsing error, false is 1088 // returned and Error() can be queried for the exact failure. 1089 func (it *ContractExtenderNewContractExtensionContractCreatedIterator) Next() bool { 1090 // If the iterator failed, stop iterating 1091 if it.fail != nil { 1092 return false 1093 } 1094 // If the iterator completed, deliver directly whatever's available 1095 if it.done { 1096 select { 1097 case log := <-it.logs: 1098 it.Event = new(ContractExtenderNewContractExtensionContractCreated) 1099 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1100 it.fail = err 1101 return false 1102 } 1103 it.Event.Raw = log 1104 return true 1105 1106 default: 1107 return false 1108 } 1109 } 1110 // Iterator still in progress, wait for either a data or an error event 1111 select { 1112 case log := <-it.logs: 1113 it.Event = new(ContractExtenderNewContractExtensionContractCreated) 1114 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1115 it.fail = err 1116 return false 1117 } 1118 it.Event.Raw = log 1119 return true 1120 1121 case err := <-it.sub.Err(): 1122 it.done = true 1123 it.fail = err 1124 return it.Next() 1125 } 1126 } 1127 1128 // Error returns any retrieval or parsing error occurred during filtering. 1129 func (it *ContractExtenderNewContractExtensionContractCreatedIterator) Error() error { 1130 return it.fail 1131 } 1132 1133 // Close terminates the iteration process, releasing any pending underlying 1134 // resources. 1135 func (it *ContractExtenderNewContractExtensionContractCreatedIterator) Close() error { 1136 it.sub.Unsubscribe() 1137 return nil 1138 } 1139 1140 // ContractExtenderNewContractExtensionContractCreated represents a NewContractExtensionContractCreated event raised by the ContractExtender contract. 1141 type ContractExtenderNewContractExtensionContractCreated struct { 1142 ToExtend common.Address 1143 RecipientPTMKey string 1144 RecipientAddress common.Address 1145 Raw types.Log // Blockchain specific contextual infos 1146 } 1147 1148 // FilterNewContractExtensionContractCreated is a free log retrieval operation binding the contract event 0x04576ede6057794ada68966eebc285c98a2726cbc4929ffd1ad9900336728d93. 1149 // 1150 // Solidity: event NewContractExtensionContractCreated(address toExtend, string recipientPTMKey, address recipientAddress) 1151 func (_ContractExtender *ContractExtenderFilterer) FilterNewContractExtensionContractCreated(opts *bind.FilterOpts) (*ContractExtenderNewContractExtensionContractCreatedIterator, error) { 1152 1153 logs, sub, err := _ContractExtender.contract.FilterLogs(opts, "NewContractExtensionContractCreated") 1154 if err != nil { 1155 return nil, err 1156 } 1157 return &ContractExtenderNewContractExtensionContractCreatedIterator{contract: _ContractExtender.contract, event: "NewContractExtensionContractCreated", logs: logs, sub: sub}, nil 1158 } 1159 1160 var NewContractExtensionContractCreatedTopicHash = "0x04576ede6057794ada68966eebc285c98a2726cbc4929ffd1ad9900336728d93" 1161 1162 // WatchNewContractExtensionContractCreated is a free log subscription operation binding the contract event 0x04576ede6057794ada68966eebc285c98a2726cbc4929ffd1ad9900336728d93. 1163 // 1164 // Solidity: event NewContractExtensionContractCreated(address toExtend, string recipientPTMKey, address recipientAddress) 1165 func (_ContractExtender *ContractExtenderFilterer) WatchNewContractExtensionContractCreated(opts *bind.WatchOpts, sink chan<- *ContractExtenderNewContractExtensionContractCreated) (event.Subscription, error) { 1166 1167 logs, sub, err := _ContractExtender.contract.WatchLogs(opts, "NewContractExtensionContractCreated") 1168 if err != nil { 1169 return nil, err 1170 } 1171 return event.NewSubscription(func(quit <-chan struct{}) error { 1172 defer sub.Unsubscribe() 1173 for { 1174 select { 1175 case log := <-logs: 1176 // New log arrived, parse the event and forward to the user 1177 event := new(ContractExtenderNewContractExtensionContractCreated) 1178 if err := _ContractExtender.contract.UnpackLog(event, "NewContractExtensionContractCreated", log); err != nil { 1179 return err 1180 } 1181 event.Raw = log 1182 1183 select { 1184 case sink <- event: 1185 case err := <-sub.Err(): 1186 return err 1187 case <-quit: 1188 return nil 1189 } 1190 case err := <-sub.Err(): 1191 return err 1192 case <-quit: 1193 return nil 1194 } 1195 } 1196 }), nil 1197 } 1198 1199 // ParseNewContractExtensionContractCreated is a log parse operation binding the contract event 0x04576ede6057794ada68966eebc285c98a2726cbc4929ffd1ad9900336728d93. 1200 // 1201 // Solidity: event NewContractExtensionContractCreated(address toExtend, string recipientPTMKey, address recipientAddress) 1202 func (_ContractExtender *ContractExtenderFilterer) ParseNewContractExtensionContractCreated(log types.Log) (*ContractExtenderNewContractExtensionContractCreated, error) { 1203 event := new(ContractExtenderNewContractExtensionContractCreated) 1204 if err := _ContractExtender.contract.UnpackLog(event, "NewContractExtensionContractCreated", log); err != nil { 1205 return nil, err 1206 } 1207 return event, nil 1208 } 1209 1210 // ContractExtenderNewVoteIterator is returned from FilterNewVote and is used to iterate over the raw logs and unpacked data for NewVote events raised by the ContractExtender contract. 1211 type ContractExtenderNewVoteIterator struct { 1212 Event *ContractExtenderNewVote // Event containing the contract specifics and raw log 1213 1214 contract *bind.BoundContract // Generic contract to use for unpacking event data 1215 event string // Event name to use for unpacking event data 1216 1217 logs chan types.Log // Log channel receiving the found contract events 1218 sub ethereum.Subscription // Subscription for errors, completion and termination 1219 done bool // Whether the subscription completed delivering logs 1220 fail error // Occurred error to stop iteration 1221 } 1222 1223 // Next advances the iterator to the subsequent event, returning whether there 1224 // are any more events found. In case of a retrieval or parsing error, false is 1225 // returned and Error() can be queried for the exact failure. 1226 func (it *ContractExtenderNewVoteIterator) Next() bool { 1227 // If the iterator failed, stop iterating 1228 if it.fail != nil { 1229 return false 1230 } 1231 // If the iterator completed, deliver directly whatever's available 1232 if it.done { 1233 select { 1234 case log := <-it.logs: 1235 it.Event = new(ContractExtenderNewVote) 1236 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1237 it.fail = err 1238 return false 1239 } 1240 it.Event.Raw = log 1241 return true 1242 1243 default: 1244 return false 1245 } 1246 } 1247 // Iterator still in progress, wait for either a data or an error event 1248 select { 1249 case log := <-it.logs: 1250 it.Event = new(ContractExtenderNewVote) 1251 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1252 it.fail = err 1253 return false 1254 } 1255 it.Event.Raw = log 1256 return true 1257 1258 case err := <-it.sub.Err(): 1259 it.done = true 1260 it.fail = err 1261 return it.Next() 1262 } 1263 } 1264 1265 // Error returns any retrieval or parsing error occurred during filtering. 1266 func (it *ContractExtenderNewVoteIterator) Error() error { 1267 return it.fail 1268 } 1269 1270 // Close terminates the iteration process, releasing any pending underlying 1271 // resources. 1272 func (it *ContractExtenderNewVoteIterator) Close() error { 1273 it.sub.Unsubscribe() 1274 return nil 1275 } 1276 1277 // ContractExtenderNewVote represents a NewVote event raised by the ContractExtender contract. 1278 type ContractExtenderNewVote struct { 1279 Vote bool 1280 Voter common.Address 1281 Raw types.Log // Blockchain specific contextual infos 1282 } 1283 1284 // FilterNewVote is a free log retrieval operation binding the contract event 0x225708d30006b0cc86d855ab91047edb5fe9c2e416412f36c18c6e90fe4e461f. 1285 // 1286 // Solidity: event NewVote(bool vote, address voter) 1287 func (_ContractExtender *ContractExtenderFilterer) FilterNewVote(opts *bind.FilterOpts) (*ContractExtenderNewVoteIterator, error) { 1288 1289 logs, sub, err := _ContractExtender.contract.FilterLogs(opts, "NewVote") 1290 if err != nil { 1291 return nil, err 1292 } 1293 return &ContractExtenderNewVoteIterator{contract: _ContractExtender.contract, event: "NewVote", logs: logs, sub: sub}, nil 1294 } 1295 1296 var NewVoteTopicHash = "0x225708d30006b0cc86d855ab91047edb5fe9c2e416412f36c18c6e90fe4e461f" 1297 1298 // WatchNewVote is a free log subscription operation binding the contract event 0x225708d30006b0cc86d855ab91047edb5fe9c2e416412f36c18c6e90fe4e461f. 1299 // 1300 // Solidity: event NewVote(bool vote, address voter) 1301 func (_ContractExtender *ContractExtenderFilterer) WatchNewVote(opts *bind.WatchOpts, sink chan<- *ContractExtenderNewVote) (event.Subscription, error) { 1302 1303 logs, sub, err := _ContractExtender.contract.WatchLogs(opts, "NewVote") 1304 if err != nil { 1305 return nil, err 1306 } 1307 return event.NewSubscription(func(quit <-chan struct{}) error { 1308 defer sub.Unsubscribe() 1309 for { 1310 select { 1311 case log := <-logs: 1312 // New log arrived, parse the event and forward to the user 1313 event := new(ContractExtenderNewVote) 1314 if err := _ContractExtender.contract.UnpackLog(event, "NewVote", log); err != nil { 1315 return err 1316 } 1317 event.Raw = log 1318 1319 select { 1320 case sink <- event: 1321 case err := <-sub.Err(): 1322 return err 1323 case <-quit: 1324 return nil 1325 } 1326 case err := <-sub.Err(): 1327 return err 1328 case <-quit: 1329 return nil 1330 } 1331 } 1332 }), nil 1333 } 1334 1335 // ParseNewVote is a log parse operation binding the contract event 0x225708d30006b0cc86d855ab91047edb5fe9c2e416412f36c18c6e90fe4e461f. 1336 // 1337 // Solidity: event NewVote(bool vote, address voter) 1338 func (_ContractExtender *ContractExtenderFilterer) ParseNewVote(log types.Log) (*ContractExtenderNewVote, error) { 1339 event := new(ContractExtenderNewVote) 1340 if err := _ContractExtender.contract.UnpackLog(event, "NewVote", log); err != nil { 1341 return nil, err 1342 } 1343 return event, nil 1344 } 1345 1346 // ContractExtenderStateSharedIterator is returned from FilterStateShared and is used to iterate over the raw logs and unpacked data for StateShared events raised by the ContractExtender contract. 1347 type ContractExtenderStateSharedIterator struct { 1348 Event *ContractExtenderStateShared // Event containing the contract specifics and raw log 1349 1350 contract *bind.BoundContract // Generic contract to use for unpacking event data 1351 event string // Event name to use for unpacking event data 1352 1353 logs chan types.Log // Log channel receiving the found contract events 1354 sub ethereum.Subscription // Subscription for errors, completion and termination 1355 done bool // Whether the subscription completed delivering logs 1356 fail error // Occurred error to stop iteration 1357 } 1358 1359 // Next advances the iterator to the subsequent event, returning whether there 1360 // are any more events found. In case of a retrieval or parsing error, false is 1361 // returned and Error() can be queried for the exact failure. 1362 func (it *ContractExtenderStateSharedIterator) Next() bool { 1363 // If the iterator failed, stop iterating 1364 if it.fail != nil { 1365 return false 1366 } 1367 // If the iterator completed, deliver directly whatever's available 1368 if it.done { 1369 select { 1370 case log := <-it.logs: 1371 it.Event = new(ContractExtenderStateShared) 1372 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1373 it.fail = err 1374 return false 1375 } 1376 it.Event.Raw = log 1377 return true 1378 1379 default: 1380 return false 1381 } 1382 } 1383 // Iterator still in progress, wait for either a data or an error event 1384 select { 1385 case log := <-it.logs: 1386 it.Event = new(ContractExtenderStateShared) 1387 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1388 it.fail = err 1389 return false 1390 } 1391 it.Event.Raw = log 1392 return true 1393 1394 case err := <-it.sub.Err(): 1395 it.done = true 1396 it.fail = err 1397 return it.Next() 1398 } 1399 } 1400 1401 // Error returns any retrieval or parsing error occurred during filtering. 1402 func (it *ContractExtenderStateSharedIterator) Error() error { 1403 return it.fail 1404 } 1405 1406 // Close terminates the iteration process, releasing any pending underlying 1407 // resources. 1408 func (it *ContractExtenderStateSharedIterator) Close() error { 1409 it.sub.Unsubscribe() 1410 return nil 1411 } 1412 1413 // ContractExtenderStateShared represents a StateShared event raised by the ContractExtender contract. 1414 type ContractExtenderStateShared struct { 1415 ToExtend common.Address 1416 Tesserahash string 1417 Uuid string 1418 Raw types.Log // Blockchain specific contextual infos 1419 } 1420 1421 // FilterStateShared is a free log retrieval operation binding the contract event 0x67a92539f3cbd7c5a9b36c23c0e2beceb27d2e1b3cd8eda02c623689267ae71e. 1422 // 1423 // Solidity: event StateShared(address toExtend, string tesserahash, string uuid) 1424 func (_ContractExtender *ContractExtenderFilterer) FilterStateShared(opts *bind.FilterOpts) (*ContractExtenderStateSharedIterator, error) { 1425 1426 logs, sub, err := _ContractExtender.contract.FilterLogs(opts, "StateShared") 1427 if err != nil { 1428 return nil, err 1429 } 1430 return &ContractExtenderStateSharedIterator{contract: _ContractExtender.contract, event: "StateShared", logs: logs, sub: sub}, nil 1431 } 1432 1433 var StateSharedTopicHash = "0x67a92539f3cbd7c5a9b36c23c0e2beceb27d2e1b3cd8eda02c623689267ae71e" 1434 1435 // WatchStateShared is a free log subscription operation binding the contract event 0x67a92539f3cbd7c5a9b36c23c0e2beceb27d2e1b3cd8eda02c623689267ae71e. 1436 // 1437 // Solidity: event StateShared(address toExtend, string tesserahash, string uuid) 1438 func (_ContractExtender *ContractExtenderFilterer) WatchStateShared(opts *bind.WatchOpts, sink chan<- *ContractExtenderStateShared) (event.Subscription, error) { 1439 1440 logs, sub, err := _ContractExtender.contract.WatchLogs(opts, "StateShared") 1441 if err != nil { 1442 return nil, err 1443 } 1444 return event.NewSubscription(func(quit <-chan struct{}) error { 1445 defer sub.Unsubscribe() 1446 for { 1447 select { 1448 case log := <-logs: 1449 // New log arrived, parse the event and forward to the user 1450 event := new(ContractExtenderStateShared) 1451 if err := _ContractExtender.contract.UnpackLog(event, "StateShared", log); err != nil { 1452 return err 1453 } 1454 event.Raw = log 1455 1456 select { 1457 case sink <- event: 1458 case err := <-sub.Err(): 1459 return err 1460 case <-quit: 1461 return nil 1462 } 1463 case err := <-sub.Err(): 1464 return err 1465 case <-quit: 1466 return nil 1467 } 1468 } 1469 }), nil 1470 } 1471 1472 // ParseStateShared is a log parse operation binding the contract event 0x67a92539f3cbd7c5a9b36c23c0e2beceb27d2e1b3cd8eda02c623689267ae71e. 1473 // 1474 // Solidity: event StateShared(address toExtend, string tesserahash, string uuid) 1475 func (_ContractExtender *ContractExtenderFilterer) ParseStateShared(log types.Log) (*ContractExtenderStateShared, error) { 1476 event := new(ContractExtenderStateShared) 1477 if err := _ContractExtender.contract.UnpackLog(event, "StateShared", log); err != nil { 1478 return nil, err 1479 } 1480 return event, nil 1481 } 1482 1483 // ContractExtenderUpdateMembersIterator is returned from FilterUpdateMembers and is used to iterate over the raw logs and unpacked data for UpdateMembers events raised by the ContractExtender contract. 1484 type ContractExtenderUpdateMembersIterator struct { 1485 Event *ContractExtenderUpdateMembers // Event containing the contract specifics and raw log 1486 1487 contract *bind.BoundContract // Generic contract to use for unpacking event data 1488 event string // Event name to use for unpacking event data 1489 1490 logs chan types.Log // Log channel receiving the found contract events 1491 sub ethereum.Subscription // Subscription for errors, completion and termination 1492 done bool // Whether the subscription completed delivering logs 1493 fail error // Occurred error to stop iteration 1494 } 1495 1496 // Next advances the iterator to the subsequent event, returning whether there 1497 // are any more events found. In case of a retrieval or parsing error, false is 1498 // returned and Error() can be queried for the exact failure. 1499 func (it *ContractExtenderUpdateMembersIterator) Next() bool { 1500 // If the iterator failed, stop iterating 1501 if it.fail != nil { 1502 return false 1503 } 1504 // If the iterator completed, deliver directly whatever's available 1505 if it.done { 1506 select { 1507 case log := <-it.logs: 1508 it.Event = new(ContractExtenderUpdateMembers) 1509 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1510 it.fail = err 1511 return false 1512 } 1513 it.Event.Raw = log 1514 return true 1515 1516 default: 1517 return false 1518 } 1519 } 1520 // Iterator still in progress, wait for either a data or an error event 1521 select { 1522 case log := <-it.logs: 1523 it.Event = new(ContractExtenderUpdateMembers) 1524 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1525 it.fail = err 1526 return false 1527 } 1528 it.Event.Raw = log 1529 return true 1530 1531 case err := <-it.sub.Err(): 1532 it.done = true 1533 it.fail = err 1534 return it.Next() 1535 } 1536 } 1537 1538 // Error returns any retrieval or parsing error occurred during filtering. 1539 func (it *ContractExtenderUpdateMembersIterator) Error() error { 1540 return it.fail 1541 } 1542 1543 // Close terminates the iteration process, releasing any pending underlying 1544 // resources. 1545 func (it *ContractExtenderUpdateMembersIterator) Close() error { 1546 it.sub.Unsubscribe() 1547 return nil 1548 } 1549 1550 // ContractExtenderUpdateMembers represents a UpdateMembers event raised by the ContractExtender contract. 1551 type ContractExtenderUpdateMembers struct { 1552 ToExtend common.Address 1553 Uuid string 1554 Raw types.Log // Blockchain specific contextual infos 1555 } 1556 1557 // FilterUpdateMembers is a free log retrieval operation binding the contract event 0x8adc4573f947f9930560525736f61b116be55049125cb63a36887a40f92f3b44. 1558 // 1559 // Solidity: event UpdateMembers(address toExtend, string uuid) 1560 func (_ContractExtender *ContractExtenderFilterer) FilterUpdateMembers(opts *bind.FilterOpts) (*ContractExtenderUpdateMembersIterator, error) { 1561 1562 logs, sub, err := _ContractExtender.contract.FilterLogs(opts, "UpdateMembers") 1563 if err != nil { 1564 return nil, err 1565 } 1566 return &ContractExtenderUpdateMembersIterator{contract: _ContractExtender.contract, event: "UpdateMembers", logs: logs, sub: sub}, nil 1567 } 1568 1569 var UpdateMembersTopicHash = "0x8adc4573f947f9930560525736f61b116be55049125cb63a36887a40f92f3b44" 1570 1571 // WatchUpdateMembers is a free log subscription operation binding the contract event 0x8adc4573f947f9930560525736f61b116be55049125cb63a36887a40f92f3b44. 1572 // 1573 // Solidity: event UpdateMembers(address toExtend, string uuid) 1574 func (_ContractExtender *ContractExtenderFilterer) WatchUpdateMembers(opts *bind.WatchOpts, sink chan<- *ContractExtenderUpdateMembers) (event.Subscription, error) { 1575 1576 logs, sub, err := _ContractExtender.contract.WatchLogs(opts, "UpdateMembers") 1577 if err != nil { 1578 return nil, err 1579 } 1580 return event.NewSubscription(func(quit <-chan struct{}) error { 1581 defer sub.Unsubscribe() 1582 for { 1583 select { 1584 case log := <-logs: 1585 // New log arrived, parse the event and forward to the user 1586 event := new(ContractExtenderUpdateMembers) 1587 if err := _ContractExtender.contract.UnpackLog(event, "UpdateMembers", log); err != nil { 1588 return err 1589 } 1590 event.Raw = log 1591 1592 select { 1593 case sink <- event: 1594 case err := <-sub.Err(): 1595 return err 1596 case <-quit: 1597 return nil 1598 } 1599 case err := <-sub.Err(): 1600 return err 1601 case <-quit: 1602 return nil 1603 } 1604 } 1605 }), nil 1606 } 1607 1608 // ParseUpdateMembers is a log parse operation binding the contract event 0x8adc4573f947f9930560525736f61b116be55049125cb63a36887a40f92f3b44. 1609 // 1610 // Solidity: event UpdateMembers(address toExtend, string uuid) 1611 func (_ContractExtender *ContractExtenderFilterer) ParseUpdateMembers(log types.Log) (*ContractExtenderUpdateMembers, error) { 1612 event := new(ContractExtenderUpdateMembers) 1613 if err := _ContractExtender.contract.UnpackLog(event, "UpdateMembers", log); err != nil { 1614 return nil, err 1615 } 1616 return event, nil 1617 }