github.com/XinFinOrg/xdcchain@v1.1.0/contracts/multisigwallet/contract/multisigwallet.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 contract 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 // MultiSigWalletABI is the input ABI used to generate the binding from. 19 const MultiSigWalletABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"owners\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"removeOwner\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"transactionId\",\"type\":\"uint256\"}],\"name\":\"revokeConfirmation\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"}],\"name\":\"isOwner\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"uint256\"},{\"name\":\"\",\"type\":\"address\"}],\"name\":\"confirmations\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"pending\",\"type\":\"bool\"},{\"name\":\"executed\",\"type\":\"bool\"}],\"name\":\"getTransactionCount\",\"outputs\":[{\"name\":\"count\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"addOwner\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"transactionId\",\"type\":\"uint256\"}],\"name\":\"isConfirmed\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"transactionId\",\"type\":\"uint256\"}],\"name\":\"getConfirmationCount\",\"outputs\":[{\"name\":\"count\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"transactions\",\"outputs\":[{\"name\":\"destination\",\"type\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\"},{\"name\":\"executed\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"getOwners\",\"outputs\":[{\"name\":\"\",\"type\":\"address[]\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"from\",\"type\":\"uint256\"},{\"name\":\"to\",\"type\":\"uint256\"},{\"name\":\"pending\",\"type\":\"bool\"},{\"name\":\"executed\",\"type\":\"bool\"}],\"name\":\"getTransactionIds\",\"outputs\":[{\"name\":\"_transactionIds\",\"type\":\"uint256[]\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"transactionId\",\"type\":\"uint256\"}],\"name\":\"getConfirmations\",\"outputs\":[{\"name\":\"_confirmations\",\"type\":\"address[]\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"transactionCount\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_required\",\"type\":\"uint256\"}],\"name\":\"changeRequirement\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"transactionId\",\"type\":\"uint256\"}],\"name\":\"confirmTransaction\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"destination\",\"type\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"submitTransaction\",\"outputs\":[{\"name\":\"transactionId\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"MAX_OWNER_COUNT\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"required\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"replaceOwner\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"transactionId\",\"type\":\"uint256\"}],\"name\":\"executeTransaction\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"name\":\"_owners\",\"type\":\"address[]\"},{\"name\":\"_required\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"payable\":true,\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"transactionId\",\"type\":\"uint256\"}],\"name\":\"Confirmation\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"transactionId\",\"type\":\"uint256\"}],\"name\":\"Revocation\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"transactionId\",\"type\":\"uint256\"}],\"name\":\"Submission\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"transactionId\",\"type\":\"uint256\"}],\"name\":\"Execution\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"transactionId\",\"type\":\"uint256\"}],\"name\":\"ExecutionFailure\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"OwnerAddition\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"OwnerRemoval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"required\",\"type\":\"uint256\"}],\"name\":\"RequirementChange\",\"type\":\"event\"}]" 20 21 // MultiSigWalletBin is the compiled bytecode used for deploying new contracts. 22 const MultiSigWalletBin = `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` 23 24 // DeployMultiSigWallet deploys a new Ethereum contract, binding an instance of MultiSigWallet to it. 25 func DeployMultiSigWallet(auth *bind.TransactOpts, backend bind.ContractBackend, _owners []common.Address, _required *big.Int) (common.Address, *types.Transaction, *MultiSigWallet, error) { 26 parsed, err := abi.JSON(strings.NewReader(MultiSigWalletABI)) 27 if err != nil { 28 return common.Address{}, nil, nil, err 29 } 30 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(MultiSigWalletBin), backend, _owners, _required) 31 if err != nil { 32 return common.Address{}, nil, nil, err 33 } 34 return address, tx, &MultiSigWallet{MultiSigWalletCaller: MultiSigWalletCaller{contract: contract}, MultiSigWalletTransactor: MultiSigWalletTransactor{contract: contract}, MultiSigWalletFilterer: MultiSigWalletFilterer{contract: contract}}, nil 35 } 36 37 // MultiSigWallet is an auto generated Go binding around an Ethereum contract. 38 type MultiSigWallet struct { 39 MultiSigWalletCaller // Read-only binding to the contract 40 MultiSigWalletTransactor // Write-only binding to the contract 41 MultiSigWalletFilterer // Log filterer for contract events 42 } 43 44 // MultiSigWalletCaller is an auto generated read-only Go binding around an Ethereum contract. 45 type MultiSigWalletCaller struct { 46 contract *bind.BoundContract // Generic contract wrapper for the low level calls 47 } 48 49 // MultiSigWalletTransactor is an auto generated write-only Go binding around an Ethereum contract. 50 type MultiSigWalletTransactor struct { 51 contract *bind.BoundContract // Generic contract wrapper for the low level calls 52 } 53 54 // MultiSigWalletFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 55 type MultiSigWalletFilterer struct { 56 contract *bind.BoundContract // Generic contract wrapper for the low level calls 57 } 58 59 // MultiSigWalletSession is an auto generated Go binding around an Ethereum contract, 60 // with pre-set call and transact options. 61 type MultiSigWalletSession struct { 62 Contract *MultiSigWallet // Generic contract binding to set the session for 63 CallOpts bind.CallOpts // Call options to use throughout this session 64 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 65 } 66 67 // MultiSigWalletCallerSession is an auto generated read-only Go binding around an Ethereum contract, 68 // with pre-set call options. 69 type MultiSigWalletCallerSession struct { 70 Contract *MultiSigWalletCaller // Generic contract caller binding to set the session for 71 CallOpts bind.CallOpts // Call options to use throughout this session 72 } 73 74 // MultiSigWalletTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 75 // with pre-set transact options. 76 type MultiSigWalletTransactorSession struct { 77 Contract *MultiSigWalletTransactor // Generic contract transactor binding to set the session for 78 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 79 } 80 81 // MultiSigWalletRaw is an auto generated low-level Go binding around an Ethereum contract. 82 type MultiSigWalletRaw struct { 83 Contract *MultiSigWallet // Generic contract binding to access the raw methods on 84 } 85 86 // MultiSigWalletCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 87 type MultiSigWalletCallerRaw struct { 88 Contract *MultiSigWalletCaller // Generic read-only contract binding to access the raw methods on 89 } 90 91 // MultiSigWalletTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 92 type MultiSigWalletTransactorRaw struct { 93 Contract *MultiSigWalletTransactor // Generic write-only contract binding to access the raw methods on 94 } 95 96 // NewMultiSigWallet creates a new instance of MultiSigWallet, bound to a specific deployed contract. 97 func NewMultiSigWallet(address common.Address, backend bind.ContractBackend) (*MultiSigWallet, error) { 98 contract, err := bindMultiSigWallet(address, backend, backend, backend) 99 if err != nil { 100 return nil, err 101 } 102 return &MultiSigWallet{MultiSigWalletCaller: MultiSigWalletCaller{contract: contract}, MultiSigWalletTransactor: MultiSigWalletTransactor{contract: contract}, MultiSigWalletFilterer: MultiSigWalletFilterer{contract: contract}}, nil 103 } 104 105 // NewMultiSigWalletCaller creates a new read-only instance of MultiSigWallet, bound to a specific deployed contract. 106 func NewMultiSigWalletCaller(address common.Address, caller bind.ContractCaller) (*MultiSigWalletCaller, error) { 107 contract, err := bindMultiSigWallet(address, caller, nil, nil) 108 if err != nil { 109 return nil, err 110 } 111 return &MultiSigWalletCaller{contract: contract}, nil 112 } 113 114 // NewMultiSigWalletTransactor creates a new write-only instance of MultiSigWallet, bound to a specific deployed contract. 115 func NewMultiSigWalletTransactor(address common.Address, transactor bind.ContractTransactor) (*MultiSigWalletTransactor, error) { 116 contract, err := bindMultiSigWallet(address, nil, transactor, nil) 117 if err != nil { 118 return nil, err 119 } 120 return &MultiSigWalletTransactor{contract: contract}, nil 121 } 122 123 // NewMultiSigWalletFilterer creates a new log filterer instance of MultiSigWallet, bound to a specific deployed contract. 124 func NewMultiSigWalletFilterer(address common.Address, filterer bind.ContractFilterer) (*MultiSigWalletFilterer, error) { 125 contract, err := bindMultiSigWallet(address, nil, nil, filterer) 126 if err != nil { 127 return nil, err 128 } 129 return &MultiSigWalletFilterer{contract: contract}, nil 130 } 131 132 // bindMultiSigWallet binds a generic wrapper to an already deployed contract. 133 func bindMultiSigWallet(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 134 parsed, err := abi.JSON(strings.NewReader(MultiSigWalletABI)) 135 if err != nil { 136 return nil, err 137 } 138 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 139 } 140 141 // Call invokes the (constant) contract method with params as input values and 142 // sets the output to result. The result type might be a single field for simple 143 // returns, a slice of interfaces for anonymous returns and a struct for named 144 // returns. 145 func (_MultiSigWallet *MultiSigWalletRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 146 return _MultiSigWallet.Contract.MultiSigWalletCaller.contract.Call(opts, result, method, params...) 147 } 148 149 // Transfer initiates a plain transaction to move funds to the contract, calling 150 // its default method if one is available. 151 func (_MultiSigWallet *MultiSigWalletRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 152 return _MultiSigWallet.Contract.MultiSigWalletTransactor.contract.Transfer(opts) 153 } 154 155 // Transact invokes the (paid) contract method with params as input values. 156 func (_MultiSigWallet *MultiSigWalletRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 157 return _MultiSigWallet.Contract.MultiSigWalletTransactor.contract.Transact(opts, method, params...) 158 } 159 160 // Call invokes the (constant) contract method with params as input values and 161 // sets the output to result. The result type might be a single field for simple 162 // returns, a slice of interfaces for anonymous returns and a struct for named 163 // returns. 164 func (_MultiSigWallet *MultiSigWalletCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 165 return _MultiSigWallet.Contract.contract.Call(opts, result, method, params...) 166 } 167 168 // Transfer initiates a plain transaction to move funds to the contract, calling 169 // its default method if one is available. 170 func (_MultiSigWallet *MultiSigWalletTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 171 return _MultiSigWallet.Contract.contract.Transfer(opts) 172 } 173 174 // Transact invokes the (paid) contract method with params as input values. 175 func (_MultiSigWallet *MultiSigWalletTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 176 return _MultiSigWallet.Contract.contract.Transact(opts, method, params...) 177 } 178 179 // MAXOWNERCOUNT is a free data retrieval call binding the contract method 0xd74f8edd. 180 // 181 // Solidity: function MAX_OWNER_COUNT() constant returns(uint256) 182 func (_MultiSigWallet *MultiSigWalletCaller) MAXOWNERCOUNT(opts *bind.CallOpts) (*big.Int, error) { 183 var ( 184 ret0 = new(*big.Int) 185 ) 186 out := ret0 187 err := _MultiSigWallet.contract.Call(opts, out, "MAX_OWNER_COUNT") 188 return *ret0, err 189 } 190 191 // MAXOWNERCOUNT is a free data retrieval call binding the contract method 0xd74f8edd. 192 // 193 // Solidity: function MAX_OWNER_COUNT() constant returns(uint256) 194 func (_MultiSigWallet *MultiSigWalletSession) MAXOWNERCOUNT() (*big.Int, error) { 195 return _MultiSigWallet.Contract.MAXOWNERCOUNT(&_MultiSigWallet.CallOpts) 196 } 197 198 // MAXOWNERCOUNT is a free data retrieval call binding the contract method 0xd74f8edd. 199 // 200 // Solidity: function MAX_OWNER_COUNT() constant returns(uint256) 201 func (_MultiSigWallet *MultiSigWalletCallerSession) MAXOWNERCOUNT() (*big.Int, error) { 202 return _MultiSigWallet.Contract.MAXOWNERCOUNT(&_MultiSigWallet.CallOpts) 203 } 204 205 // Confirmations is a free data retrieval call binding the contract method 0x3411c81c. 206 // 207 // Solidity: function confirmations( uint256, address) constant returns(bool) 208 func (_MultiSigWallet *MultiSigWalletCaller) Confirmations(opts *bind.CallOpts, arg0 *big.Int, arg1 common.Address) (bool, error) { 209 var ( 210 ret0 = new(bool) 211 ) 212 out := ret0 213 err := _MultiSigWallet.contract.Call(opts, out, "confirmations", arg0, arg1) 214 return *ret0, err 215 } 216 217 // Confirmations is a free data retrieval call binding the contract method 0x3411c81c. 218 // 219 // Solidity: function confirmations( uint256, address) constant returns(bool) 220 func (_MultiSigWallet *MultiSigWalletSession) Confirmations(arg0 *big.Int, arg1 common.Address) (bool, error) { 221 return _MultiSigWallet.Contract.Confirmations(&_MultiSigWallet.CallOpts, arg0, arg1) 222 } 223 224 // Confirmations is a free data retrieval call binding the contract method 0x3411c81c. 225 // 226 // Solidity: function confirmations( uint256, address) constant returns(bool) 227 func (_MultiSigWallet *MultiSigWalletCallerSession) Confirmations(arg0 *big.Int, arg1 common.Address) (bool, error) { 228 return _MultiSigWallet.Contract.Confirmations(&_MultiSigWallet.CallOpts, arg0, arg1) 229 } 230 231 // GetConfirmationCount is a free data retrieval call binding the contract method 0x8b51d13f. 232 // 233 // Solidity: function getConfirmationCount(transactionId uint256) constant returns(count uint256) 234 func (_MultiSigWallet *MultiSigWalletCaller) GetConfirmationCount(opts *bind.CallOpts, transactionId *big.Int) (*big.Int, error) { 235 var ( 236 ret0 = new(*big.Int) 237 ) 238 out := ret0 239 err := _MultiSigWallet.contract.Call(opts, out, "getConfirmationCount", transactionId) 240 return *ret0, err 241 } 242 243 // GetConfirmationCount is a free data retrieval call binding the contract method 0x8b51d13f. 244 // 245 // Solidity: function getConfirmationCount(transactionId uint256) constant returns(count uint256) 246 func (_MultiSigWallet *MultiSigWalletSession) GetConfirmationCount(transactionId *big.Int) (*big.Int, error) { 247 return _MultiSigWallet.Contract.GetConfirmationCount(&_MultiSigWallet.CallOpts, transactionId) 248 } 249 250 // GetConfirmationCount is a free data retrieval call binding the contract method 0x8b51d13f. 251 // 252 // Solidity: function getConfirmationCount(transactionId uint256) constant returns(count uint256) 253 func (_MultiSigWallet *MultiSigWalletCallerSession) GetConfirmationCount(transactionId *big.Int) (*big.Int, error) { 254 return _MultiSigWallet.Contract.GetConfirmationCount(&_MultiSigWallet.CallOpts, transactionId) 255 } 256 257 // GetConfirmations is a free data retrieval call binding the contract method 0xb5dc40c3. 258 // 259 // Solidity: function getConfirmations(transactionId uint256) constant returns(_confirmations address[]) 260 func (_MultiSigWallet *MultiSigWalletCaller) GetConfirmations(opts *bind.CallOpts, transactionId *big.Int) ([]common.Address, error) { 261 var ( 262 ret0 = new([]common.Address) 263 ) 264 out := ret0 265 err := _MultiSigWallet.contract.Call(opts, out, "getConfirmations", transactionId) 266 return *ret0, err 267 } 268 269 // GetConfirmations is a free data retrieval call binding the contract method 0xb5dc40c3. 270 // 271 // Solidity: function getConfirmations(transactionId uint256) constant returns(_confirmations address[]) 272 func (_MultiSigWallet *MultiSigWalletSession) GetConfirmations(transactionId *big.Int) ([]common.Address, error) { 273 return _MultiSigWallet.Contract.GetConfirmations(&_MultiSigWallet.CallOpts, transactionId) 274 } 275 276 // GetConfirmations is a free data retrieval call binding the contract method 0xb5dc40c3. 277 // 278 // Solidity: function getConfirmations(transactionId uint256) constant returns(_confirmations address[]) 279 func (_MultiSigWallet *MultiSigWalletCallerSession) GetConfirmations(transactionId *big.Int) ([]common.Address, error) { 280 return _MultiSigWallet.Contract.GetConfirmations(&_MultiSigWallet.CallOpts, transactionId) 281 } 282 283 // GetOwners is a free data retrieval call binding the contract method 0xa0e67e2b. 284 // 285 // Solidity: function getOwners() constant returns(address[]) 286 func (_MultiSigWallet *MultiSigWalletCaller) GetOwners(opts *bind.CallOpts) ([]common.Address, error) { 287 var ( 288 ret0 = new([]common.Address) 289 ) 290 out := ret0 291 err := _MultiSigWallet.contract.Call(opts, out, "getOwners") 292 return *ret0, err 293 } 294 295 // GetOwners is a free data retrieval call binding the contract method 0xa0e67e2b. 296 // 297 // Solidity: function getOwners() constant returns(address[]) 298 func (_MultiSigWallet *MultiSigWalletSession) GetOwners() ([]common.Address, error) { 299 return _MultiSigWallet.Contract.GetOwners(&_MultiSigWallet.CallOpts) 300 } 301 302 // GetOwners is a free data retrieval call binding the contract method 0xa0e67e2b. 303 // 304 // Solidity: function getOwners() constant returns(address[]) 305 func (_MultiSigWallet *MultiSigWalletCallerSession) GetOwners() ([]common.Address, error) { 306 return _MultiSigWallet.Contract.GetOwners(&_MultiSigWallet.CallOpts) 307 } 308 309 // GetTransactionCount is a free data retrieval call binding the contract method 0x54741525. 310 // 311 // Solidity: function getTransactionCount(pending bool, executed bool) constant returns(count uint256) 312 func (_MultiSigWallet *MultiSigWalletCaller) GetTransactionCount(opts *bind.CallOpts, pending bool, executed bool) (*big.Int, error) { 313 var ( 314 ret0 = new(*big.Int) 315 ) 316 out := ret0 317 err := _MultiSigWallet.contract.Call(opts, out, "getTransactionCount", pending, executed) 318 return *ret0, err 319 } 320 321 // GetTransactionCount is a free data retrieval call binding the contract method 0x54741525. 322 // 323 // Solidity: function getTransactionCount(pending bool, executed bool) constant returns(count uint256) 324 func (_MultiSigWallet *MultiSigWalletSession) GetTransactionCount(pending bool, executed bool) (*big.Int, error) { 325 return _MultiSigWallet.Contract.GetTransactionCount(&_MultiSigWallet.CallOpts, pending, executed) 326 } 327 328 // GetTransactionCount is a free data retrieval call binding the contract method 0x54741525. 329 // 330 // Solidity: function getTransactionCount(pending bool, executed bool) constant returns(count uint256) 331 func (_MultiSigWallet *MultiSigWalletCallerSession) GetTransactionCount(pending bool, executed bool) (*big.Int, error) { 332 return _MultiSigWallet.Contract.GetTransactionCount(&_MultiSigWallet.CallOpts, pending, executed) 333 } 334 335 // GetTransactionIds is a free data retrieval call binding the contract method 0xa8abe69a. 336 // 337 // Solidity: function getTransactionIds(from uint256, to uint256, pending bool, executed bool) constant returns(_transactionIds uint256[]) 338 func (_MultiSigWallet *MultiSigWalletCaller) GetTransactionIds(opts *bind.CallOpts, from *big.Int, to *big.Int, pending bool, executed bool) ([]*big.Int, error) { 339 var ( 340 ret0 = new([]*big.Int) 341 ) 342 out := ret0 343 err := _MultiSigWallet.contract.Call(opts, out, "getTransactionIds", from, to, pending, executed) 344 return *ret0, err 345 } 346 347 // GetTransactionIds is a free data retrieval call binding the contract method 0xa8abe69a. 348 // 349 // Solidity: function getTransactionIds(from uint256, to uint256, pending bool, executed bool) constant returns(_transactionIds uint256[]) 350 func (_MultiSigWallet *MultiSigWalletSession) GetTransactionIds(from *big.Int, to *big.Int, pending bool, executed bool) ([]*big.Int, error) { 351 return _MultiSigWallet.Contract.GetTransactionIds(&_MultiSigWallet.CallOpts, from, to, pending, executed) 352 } 353 354 // GetTransactionIds is a free data retrieval call binding the contract method 0xa8abe69a. 355 // 356 // Solidity: function getTransactionIds(from uint256, to uint256, pending bool, executed bool) constant returns(_transactionIds uint256[]) 357 func (_MultiSigWallet *MultiSigWalletCallerSession) GetTransactionIds(from *big.Int, to *big.Int, pending bool, executed bool) ([]*big.Int, error) { 358 return _MultiSigWallet.Contract.GetTransactionIds(&_MultiSigWallet.CallOpts, from, to, pending, executed) 359 } 360 361 // IsConfirmed is a free data retrieval call binding the contract method 0x784547a7. 362 // 363 // Solidity: function isConfirmed(transactionId uint256) constant returns(bool) 364 func (_MultiSigWallet *MultiSigWalletCaller) IsConfirmed(opts *bind.CallOpts, transactionId *big.Int) (bool, error) { 365 var ( 366 ret0 = new(bool) 367 ) 368 out := ret0 369 err := _MultiSigWallet.contract.Call(opts, out, "isConfirmed", transactionId) 370 return *ret0, err 371 } 372 373 // IsConfirmed is a free data retrieval call binding the contract method 0x784547a7. 374 // 375 // Solidity: function isConfirmed(transactionId uint256) constant returns(bool) 376 func (_MultiSigWallet *MultiSigWalletSession) IsConfirmed(transactionId *big.Int) (bool, error) { 377 return _MultiSigWallet.Contract.IsConfirmed(&_MultiSigWallet.CallOpts, transactionId) 378 } 379 380 // IsConfirmed is a free data retrieval call binding the contract method 0x784547a7. 381 // 382 // Solidity: function isConfirmed(transactionId uint256) constant returns(bool) 383 func (_MultiSigWallet *MultiSigWalletCallerSession) IsConfirmed(transactionId *big.Int) (bool, error) { 384 return _MultiSigWallet.Contract.IsConfirmed(&_MultiSigWallet.CallOpts, transactionId) 385 } 386 387 // IsOwner is a free data retrieval call binding the contract method 0x2f54bf6e. 388 // 389 // Solidity: function isOwner( address) constant returns(bool) 390 func (_MultiSigWallet *MultiSigWalletCaller) IsOwner(opts *bind.CallOpts, arg0 common.Address) (bool, error) { 391 var ( 392 ret0 = new(bool) 393 ) 394 out := ret0 395 err := _MultiSigWallet.contract.Call(opts, out, "isOwner", arg0) 396 return *ret0, err 397 } 398 399 // IsOwner is a free data retrieval call binding the contract method 0x2f54bf6e. 400 // 401 // Solidity: function isOwner( address) constant returns(bool) 402 func (_MultiSigWallet *MultiSigWalletSession) IsOwner(arg0 common.Address) (bool, error) { 403 return _MultiSigWallet.Contract.IsOwner(&_MultiSigWallet.CallOpts, arg0) 404 } 405 406 // IsOwner is a free data retrieval call binding the contract method 0x2f54bf6e. 407 // 408 // Solidity: function isOwner( address) constant returns(bool) 409 func (_MultiSigWallet *MultiSigWalletCallerSession) IsOwner(arg0 common.Address) (bool, error) { 410 return _MultiSigWallet.Contract.IsOwner(&_MultiSigWallet.CallOpts, arg0) 411 } 412 413 // Owners is a free data retrieval call binding the contract method 0x025e7c27. 414 // 415 // Solidity: function owners( uint256) constant returns(address) 416 func (_MultiSigWallet *MultiSigWalletCaller) Owners(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error) { 417 var ( 418 ret0 = new(common.Address) 419 ) 420 out := ret0 421 err := _MultiSigWallet.contract.Call(opts, out, "owners", arg0) 422 return *ret0, err 423 } 424 425 // Owners is a free data retrieval call binding the contract method 0x025e7c27. 426 // 427 // Solidity: function owners( uint256) constant returns(address) 428 func (_MultiSigWallet *MultiSigWalletSession) Owners(arg0 *big.Int) (common.Address, error) { 429 return _MultiSigWallet.Contract.Owners(&_MultiSigWallet.CallOpts, arg0) 430 } 431 432 // Owners is a free data retrieval call binding the contract method 0x025e7c27. 433 // 434 // Solidity: function owners( uint256) constant returns(address) 435 func (_MultiSigWallet *MultiSigWalletCallerSession) Owners(arg0 *big.Int) (common.Address, error) { 436 return _MultiSigWallet.Contract.Owners(&_MultiSigWallet.CallOpts, arg0) 437 } 438 439 // Required is a free data retrieval call binding the contract method 0xdc8452cd. 440 // 441 // Solidity: function required() constant returns(uint256) 442 func (_MultiSigWallet *MultiSigWalletCaller) Required(opts *bind.CallOpts) (*big.Int, error) { 443 var ( 444 ret0 = new(*big.Int) 445 ) 446 out := ret0 447 err := _MultiSigWallet.contract.Call(opts, out, "required") 448 return *ret0, err 449 } 450 451 // Required is a free data retrieval call binding the contract method 0xdc8452cd. 452 // 453 // Solidity: function required() constant returns(uint256) 454 func (_MultiSigWallet *MultiSigWalletSession) Required() (*big.Int, error) { 455 return _MultiSigWallet.Contract.Required(&_MultiSigWallet.CallOpts) 456 } 457 458 // Required is a free data retrieval call binding the contract method 0xdc8452cd. 459 // 460 // Solidity: function required() constant returns(uint256) 461 func (_MultiSigWallet *MultiSigWalletCallerSession) Required() (*big.Int, error) { 462 return _MultiSigWallet.Contract.Required(&_MultiSigWallet.CallOpts) 463 } 464 465 // TransactionCount is a free data retrieval call binding the contract method 0xb77bf600. 466 // 467 // Solidity: function transactionCount() constant returns(uint256) 468 func (_MultiSigWallet *MultiSigWalletCaller) TransactionCount(opts *bind.CallOpts) (*big.Int, error) { 469 var ( 470 ret0 = new(*big.Int) 471 ) 472 out := ret0 473 err := _MultiSigWallet.contract.Call(opts, out, "transactionCount") 474 return *ret0, err 475 } 476 477 // TransactionCount is a free data retrieval call binding the contract method 0xb77bf600. 478 // 479 // Solidity: function transactionCount() constant returns(uint256) 480 func (_MultiSigWallet *MultiSigWalletSession) TransactionCount() (*big.Int, error) { 481 return _MultiSigWallet.Contract.TransactionCount(&_MultiSigWallet.CallOpts) 482 } 483 484 // TransactionCount is a free data retrieval call binding the contract method 0xb77bf600. 485 // 486 // Solidity: function transactionCount() constant returns(uint256) 487 func (_MultiSigWallet *MultiSigWalletCallerSession) TransactionCount() (*big.Int, error) { 488 return _MultiSigWallet.Contract.TransactionCount(&_MultiSigWallet.CallOpts) 489 } 490 491 // Transactions is a free data retrieval call binding the contract method 0x9ace38c2. 492 // 493 // Solidity: function transactions( uint256) constant returns(destination address, value uint256, data bytes, executed bool) 494 func (_MultiSigWallet *MultiSigWalletCaller) Transactions(opts *bind.CallOpts, arg0 *big.Int) (struct { 495 Destination common.Address 496 Value *big.Int 497 Data []byte 498 Executed bool 499 }, error) { 500 ret := new(struct { 501 Destination common.Address 502 Value *big.Int 503 Data []byte 504 Executed bool 505 }) 506 out := ret 507 err := _MultiSigWallet.contract.Call(opts, out, "transactions", arg0) 508 return *ret, err 509 } 510 511 // Transactions is a free data retrieval call binding the contract method 0x9ace38c2. 512 // 513 // Solidity: function transactions( uint256) constant returns(destination address, value uint256, data bytes, executed bool) 514 func (_MultiSigWallet *MultiSigWalletSession) Transactions(arg0 *big.Int) (struct { 515 Destination common.Address 516 Value *big.Int 517 Data []byte 518 Executed bool 519 }, error) { 520 return _MultiSigWallet.Contract.Transactions(&_MultiSigWallet.CallOpts, arg0) 521 } 522 523 // Transactions is a free data retrieval call binding the contract method 0x9ace38c2. 524 // 525 // Solidity: function transactions( uint256) constant returns(destination address, value uint256, data bytes, executed bool) 526 func (_MultiSigWallet *MultiSigWalletCallerSession) Transactions(arg0 *big.Int) (struct { 527 Destination common.Address 528 Value *big.Int 529 Data []byte 530 Executed bool 531 }, error) { 532 return _MultiSigWallet.Contract.Transactions(&_MultiSigWallet.CallOpts, arg0) 533 } 534 535 // AddOwner is a paid mutator transaction binding the contract method 0x7065cb48. 536 // 537 // Solidity: function addOwner(owner address) returns() 538 func (_MultiSigWallet *MultiSigWalletTransactor) AddOwner(opts *bind.TransactOpts, owner common.Address) (*types.Transaction, error) { 539 return _MultiSigWallet.contract.Transact(opts, "addOwner", owner) 540 } 541 542 // AddOwner is a paid mutator transaction binding the contract method 0x7065cb48. 543 // 544 // Solidity: function addOwner(owner address) returns() 545 func (_MultiSigWallet *MultiSigWalletSession) AddOwner(owner common.Address) (*types.Transaction, error) { 546 return _MultiSigWallet.Contract.AddOwner(&_MultiSigWallet.TransactOpts, owner) 547 } 548 549 // AddOwner is a paid mutator transaction binding the contract method 0x7065cb48. 550 // 551 // Solidity: function addOwner(owner address) returns() 552 func (_MultiSigWallet *MultiSigWalletTransactorSession) AddOwner(owner common.Address) (*types.Transaction, error) { 553 return _MultiSigWallet.Contract.AddOwner(&_MultiSigWallet.TransactOpts, owner) 554 } 555 556 // ChangeRequirement is a paid mutator transaction binding the contract method 0xba51a6df. 557 // 558 // Solidity: function changeRequirement(_required uint256) returns() 559 func (_MultiSigWallet *MultiSigWalletTransactor) ChangeRequirement(opts *bind.TransactOpts, _required *big.Int) (*types.Transaction, error) { 560 return _MultiSigWallet.contract.Transact(opts, "changeRequirement", _required) 561 } 562 563 // ChangeRequirement is a paid mutator transaction binding the contract method 0xba51a6df. 564 // 565 // Solidity: function changeRequirement(_required uint256) returns() 566 func (_MultiSigWallet *MultiSigWalletSession) ChangeRequirement(_required *big.Int) (*types.Transaction, error) { 567 return _MultiSigWallet.Contract.ChangeRequirement(&_MultiSigWallet.TransactOpts, _required) 568 } 569 570 // ChangeRequirement is a paid mutator transaction binding the contract method 0xba51a6df. 571 // 572 // Solidity: function changeRequirement(_required uint256) returns() 573 func (_MultiSigWallet *MultiSigWalletTransactorSession) ChangeRequirement(_required *big.Int) (*types.Transaction, error) { 574 return _MultiSigWallet.Contract.ChangeRequirement(&_MultiSigWallet.TransactOpts, _required) 575 } 576 577 // ConfirmTransaction is a paid mutator transaction binding the contract method 0xc01a8c84. 578 // 579 // Solidity: function confirmTransaction(transactionId uint256) returns() 580 func (_MultiSigWallet *MultiSigWalletTransactor) ConfirmTransaction(opts *bind.TransactOpts, transactionId *big.Int) (*types.Transaction, error) { 581 return _MultiSigWallet.contract.Transact(opts, "confirmTransaction", transactionId) 582 } 583 584 // ConfirmTransaction is a paid mutator transaction binding the contract method 0xc01a8c84. 585 // 586 // Solidity: function confirmTransaction(transactionId uint256) returns() 587 func (_MultiSigWallet *MultiSigWalletSession) ConfirmTransaction(transactionId *big.Int) (*types.Transaction, error) { 588 return _MultiSigWallet.Contract.ConfirmTransaction(&_MultiSigWallet.TransactOpts, transactionId) 589 } 590 591 // ConfirmTransaction is a paid mutator transaction binding the contract method 0xc01a8c84. 592 // 593 // Solidity: function confirmTransaction(transactionId uint256) returns() 594 func (_MultiSigWallet *MultiSigWalletTransactorSession) ConfirmTransaction(transactionId *big.Int) (*types.Transaction, error) { 595 return _MultiSigWallet.Contract.ConfirmTransaction(&_MultiSigWallet.TransactOpts, transactionId) 596 } 597 598 // ExecuteTransaction is a paid mutator transaction binding the contract method 0xee22610b. 599 // 600 // Solidity: function executeTransaction(transactionId uint256) returns() 601 func (_MultiSigWallet *MultiSigWalletTransactor) ExecuteTransaction(opts *bind.TransactOpts, transactionId *big.Int) (*types.Transaction, error) { 602 return _MultiSigWallet.contract.Transact(opts, "executeTransaction", transactionId) 603 } 604 605 // ExecuteTransaction is a paid mutator transaction binding the contract method 0xee22610b. 606 // 607 // Solidity: function executeTransaction(transactionId uint256) returns() 608 func (_MultiSigWallet *MultiSigWalletSession) ExecuteTransaction(transactionId *big.Int) (*types.Transaction, error) { 609 return _MultiSigWallet.Contract.ExecuteTransaction(&_MultiSigWallet.TransactOpts, transactionId) 610 } 611 612 // ExecuteTransaction is a paid mutator transaction binding the contract method 0xee22610b. 613 // 614 // Solidity: function executeTransaction(transactionId uint256) returns() 615 func (_MultiSigWallet *MultiSigWalletTransactorSession) ExecuteTransaction(transactionId *big.Int) (*types.Transaction, error) { 616 return _MultiSigWallet.Contract.ExecuteTransaction(&_MultiSigWallet.TransactOpts, transactionId) 617 } 618 619 // RemoveOwner is a paid mutator transaction binding the contract method 0x173825d9. 620 // 621 // Solidity: function removeOwner(owner address) returns() 622 func (_MultiSigWallet *MultiSigWalletTransactor) RemoveOwner(opts *bind.TransactOpts, owner common.Address) (*types.Transaction, error) { 623 return _MultiSigWallet.contract.Transact(opts, "removeOwner", owner) 624 } 625 626 // RemoveOwner is a paid mutator transaction binding the contract method 0x173825d9. 627 // 628 // Solidity: function removeOwner(owner address) returns() 629 func (_MultiSigWallet *MultiSigWalletSession) RemoveOwner(owner common.Address) (*types.Transaction, error) { 630 return _MultiSigWallet.Contract.RemoveOwner(&_MultiSigWallet.TransactOpts, owner) 631 } 632 633 // RemoveOwner is a paid mutator transaction binding the contract method 0x173825d9. 634 // 635 // Solidity: function removeOwner(owner address) returns() 636 func (_MultiSigWallet *MultiSigWalletTransactorSession) RemoveOwner(owner common.Address) (*types.Transaction, error) { 637 return _MultiSigWallet.Contract.RemoveOwner(&_MultiSigWallet.TransactOpts, owner) 638 } 639 640 // ReplaceOwner is a paid mutator transaction binding the contract method 0xe20056e6. 641 // 642 // Solidity: function replaceOwner(owner address, newOwner address) returns() 643 func (_MultiSigWallet *MultiSigWalletTransactor) ReplaceOwner(opts *bind.TransactOpts, owner common.Address, newOwner common.Address) (*types.Transaction, error) { 644 return _MultiSigWallet.contract.Transact(opts, "replaceOwner", owner, newOwner) 645 } 646 647 // ReplaceOwner is a paid mutator transaction binding the contract method 0xe20056e6. 648 // 649 // Solidity: function replaceOwner(owner address, newOwner address) returns() 650 func (_MultiSigWallet *MultiSigWalletSession) ReplaceOwner(owner common.Address, newOwner common.Address) (*types.Transaction, error) { 651 return _MultiSigWallet.Contract.ReplaceOwner(&_MultiSigWallet.TransactOpts, owner, newOwner) 652 } 653 654 // ReplaceOwner is a paid mutator transaction binding the contract method 0xe20056e6. 655 // 656 // Solidity: function replaceOwner(owner address, newOwner address) returns() 657 func (_MultiSigWallet *MultiSigWalletTransactorSession) ReplaceOwner(owner common.Address, newOwner common.Address) (*types.Transaction, error) { 658 return _MultiSigWallet.Contract.ReplaceOwner(&_MultiSigWallet.TransactOpts, owner, newOwner) 659 } 660 661 // RevokeConfirmation is a paid mutator transaction binding the contract method 0x20ea8d86. 662 // 663 // Solidity: function revokeConfirmation(transactionId uint256) returns() 664 func (_MultiSigWallet *MultiSigWalletTransactor) RevokeConfirmation(opts *bind.TransactOpts, transactionId *big.Int) (*types.Transaction, error) { 665 return _MultiSigWallet.contract.Transact(opts, "revokeConfirmation", transactionId) 666 } 667 668 // RevokeConfirmation is a paid mutator transaction binding the contract method 0x20ea8d86. 669 // 670 // Solidity: function revokeConfirmation(transactionId uint256) returns() 671 func (_MultiSigWallet *MultiSigWalletSession) RevokeConfirmation(transactionId *big.Int) (*types.Transaction, error) { 672 return _MultiSigWallet.Contract.RevokeConfirmation(&_MultiSigWallet.TransactOpts, transactionId) 673 } 674 675 // RevokeConfirmation is a paid mutator transaction binding the contract method 0x20ea8d86. 676 // 677 // Solidity: function revokeConfirmation(transactionId uint256) returns() 678 func (_MultiSigWallet *MultiSigWalletTransactorSession) RevokeConfirmation(transactionId *big.Int) (*types.Transaction, error) { 679 return _MultiSigWallet.Contract.RevokeConfirmation(&_MultiSigWallet.TransactOpts, transactionId) 680 } 681 682 // SubmitTransaction is a paid mutator transaction binding the contract method 0xc6427474. 683 // 684 // Solidity: function submitTransaction(destination address, value uint256, data bytes) returns(transactionId uint256) 685 func (_MultiSigWallet *MultiSigWalletTransactor) SubmitTransaction(opts *bind.TransactOpts, destination common.Address, value *big.Int, data []byte) (*types.Transaction, error) { 686 return _MultiSigWallet.contract.Transact(opts, "submitTransaction", destination, value, data) 687 } 688 689 // SubmitTransaction is a paid mutator transaction binding the contract method 0xc6427474. 690 // 691 // Solidity: function submitTransaction(destination address, value uint256, data bytes) returns(transactionId uint256) 692 func (_MultiSigWallet *MultiSigWalletSession) SubmitTransaction(destination common.Address, value *big.Int, data []byte) (*types.Transaction, error) { 693 return _MultiSigWallet.Contract.SubmitTransaction(&_MultiSigWallet.TransactOpts, destination, value, data) 694 } 695 696 // SubmitTransaction is a paid mutator transaction binding the contract method 0xc6427474. 697 // 698 // Solidity: function submitTransaction(destination address, value uint256, data bytes) returns(transactionId uint256) 699 func (_MultiSigWallet *MultiSigWalletTransactorSession) SubmitTransaction(destination common.Address, value *big.Int, data []byte) (*types.Transaction, error) { 700 return _MultiSigWallet.Contract.SubmitTransaction(&_MultiSigWallet.TransactOpts, destination, value, data) 701 } 702 703 // MultiSigWalletConfirmationIterator is returned from FilterConfirmation and is used to iterate over the raw logs and unpacked data for Confirmation events raised by the MultiSigWallet contract. 704 type MultiSigWalletConfirmationIterator struct { 705 Event *MultiSigWalletConfirmation // Event containing the contract specifics and raw log 706 707 contract *bind.BoundContract // Generic contract to use for unpacking event data 708 event string // Event name to use for unpacking event data 709 710 logs chan types.Log // Log channel receiving the found contract events 711 sub ethereum.Subscription // Subscription for errors, completion and termination 712 done bool // Whether the subscription completed delivering logs 713 fail error // Occurred error to stop iteration 714 } 715 716 // Next advances the iterator to the subsequent event, returning whether there 717 // are any more events found. In case of a retrieval or parsing error, false is 718 // returned and Error() can be queried for the exact failure. 719 func (it *MultiSigWalletConfirmationIterator) Next() bool { 720 // If the iterator failed, stop iterating 721 if it.fail != nil { 722 return false 723 } 724 // If the iterator completed, deliver directly whatever's available 725 if it.done { 726 select { 727 case log := <-it.logs: 728 it.Event = new(MultiSigWalletConfirmation) 729 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 730 it.fail = err 731 return false 732 } 733 it.Event.Raw = log 734 return true 735 736 default: 737 return false 738 } 739 } 740 // Iterator still in progress, wait for either a data or an error event 741 select { 742 case log := <-it.logs: 743 it.Event = new(MultiSigWalletConfirmation) 744 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 745 it.fail = err 746 return false 747 } 748 it.Event.Raw = log 749 return true 750 751 case err := <-it.sub.Err(): 752 it.done = true 753 it.fail = err 754 return it.Next() 755 } 756 } 757 758 // Error returns any retrieval or parsing error occurred during filtering. 759 func (it *MultiSigWalletConfirmationIterator) Error() error { 760 return it.fail 761 } 762 763 // Close terminates the iteration process, releasing any pending underlying 764 // resources. 765 func (it *MultiSigWalletConfirmationIterator) Close() error { 766 it.sub.Unsubscribe() 767 return nil 768 } 769 770 // MultiSigWalletConfirmation represents a Confirmation event raised by the MultiSigWallet contract. 771 type MultiSigWalletConfirmation struct { 772 Sender common.Address 773 TransactionId *big.Int 774 Raw types.Log // Blockchain specific contextual infos 775 } 776 777 // FilterConfirmation is a free log retrieval operation binding the contract event 0x4a504a94899432a9846e1aa406dceb1bcfd538bb839071d49d1e5e23f5be30ef. 778 // 779 // Solidity: event Confirmation(sender indexed address, transactionId indexed uint256) 780 func (_MultiSigWallet *MultiSigWalletFilterer) FilterConfirmation(opts *bind.FilterOpts, sender []common.Address, transactionId []*big.Int) (*MultiSigWalletConfirmationIterator, error) { 781 782 var senderRule []interface{} 783 for _, senderItem := range sender { 784 senderRule = append(senderRule, senderItem) 785 } 786 var transactionIdRule []interface{} 787 for _, transactionIdItem := range transactionId { 788 transactionIdRule = append(transactionIdRule, transactionIdItem) 789 } 790 791 logs, sub, err := _MultiSigWallet.contract.FilterLogs(opts, "Confirmation", senderRule, transactionIdRule) 792 if err != nil { 793 return nil, err 794 } 795 return &MultiSigWalletConfirmationIterator{contract: _MultiSigWallet.contract, event: "Confirmation", logs: logs, sub: sub}, nil 796 } 797 798 // WatchConfirmation is a free log subscription operation binding the contract event 0x4a504a94899432a9846e1aa406dceb1bcfd538bb839071d49d1e5e23f5be30ef. 799 // 800 // Solidity: event Confirmation(sender indexed address, transactionId indexed uint256) 801 func (_MultiSigWallet *MultiSigWalletFilterer) WatchConfirmation(opts *bind.WatchOpts, sink chan<- *MultiSigWalletConfirmation, sender []common.Address, transactionId []*big.Int) (event.Subscription, error) { 802 803 var senderRule []interface{} 804 for _, senderItem := range sender { 805 senderRule = append(senderRule, senderItem) 806 } 807 var transactionIdRule []interface{} 808 for _, transactionIdItem := range transactionId { 809 transactionIdRule = append(transactionIdRule, transactionIdItem) 810 } 811 812 logs, sub, err := _MultiSigWallet.contract.WatchLogs(opts, "Confirmation", senderRule, transactionIdRule) 813 if err != nil { 814 return nil, err 815 } 816 return event.NewSubscription(func(quit <-chan struct{}) error { 817 defer sub.Unsubscribe() 818 for { 819 select { 820 case log := <-logs: 821 // New log arrived, parse the event and forward to the user 822 event := new(MultiSigWalletConfirmation) 823 if err := _MultiSigWallet.contract.UnpackLog(event, "Confirmation", log); err != nil { 824 return err 825 } 826 event.Raw = log 827 828 select { 829 case sink <- event: 830 case err := <-sub.Err(): 831 return err 832 case <-quit: 833 return nil 834 } 835 case err := <-sub.Err(): 836 return err 837 case <-quit: 838 return nil 839 } 840 } 841 }), nil 842 } 843 844 // MultiSigWalletDepositIterator is returned from FilterDeposit and is used to iterate over the raw logs and unpacked data for Deposit events raised by the MultiSigWallet contract. 845 type MultiSigWalletDepositIterator struct { 846 Event *MultiSigWalletDeposit // Event containing the contract specifics and raw log 847 848 contract *bind.BoundContract // Generic contract to use for unpacking event data 849 event string // Event name to use for unpacking event data 850 851 logs chan types.Log // Log channel receiving the found contract events 852 sub ethereum.Subscription // Subscription for errors, completion and termination 853 done bool // Whether the subscription completed delivering logs 854 fail error // Occurred error to stop iteration 855 } 856 857 // Next advances the iterator to the subsequent event, returning whether there 858 // are any more events found. In case of a retrieval or parsing error, false is 859 // returned and Error() can be queried for the exact failure. 860 func (it *MultiSigWalletDepositIterator) Next() bool { 861 // If the iterator failed, stop iterating 862 if it.fail != nil { 863 return false 864 } 865 // If the iterator completed, deliver directly whatever's available 866 if it.done { 867 select { 868 case log := <-it.logs: 869 it.Event = new(MultiSigWalletDeposit) 870 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 871 it.fail = err 872 return false 873 } 874 it.Event.Raw = log 875 return true 876 877 default: 878 return false 879 } 880 } 881 // Iterator still in progress, wait for either a data or an error event 882 select { 883 case log := <-it.logs: 884 it.Event = new(MultiSigWalletDeposit) 885 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 886 it.fail = err 887 return false 888 } 889 it.Event.Raw = log 890 return true 891 892 case err := <-it.sub.Err(): 893 it.done = true 894 it.fail = err 895 return it.Next() 896 } 897 } 898 899 // Error returns any retrieval or parsing error occurred during filtering. 900 func (it *MultiSigWalletDepositIterator) Error() error { 901 return it.fail 902 } 903 904 // Close terminates the iteration process, releasing any pending underlying 905 // resources. 906 func (it *MultiSigWalletDepositIterator) Close() error { 907 it.sub.Unsubscribe() 908 return nil 909 } 910 911 // MultiSigWalletDeposit represents a Deposit event raised by the MultiSigWallet contract. 912 type MultiSigWalletDeposit struct { 913 Sender common.Address 914 Value *big.Int 915 Raw types.Log // Blockchain specific contextual infos 916 } 917 918 // FilterDeposit is a free log retrieval operation binding the contract event 0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c. 919 // 920 // Solidity: event Deposit(sender indexed address, value uint256) 921 func (_MultiSigWallet *MultiSigWalletFilterer) FilterDeposit(opts *bind.FilterOpts, sender []common.Address) (*MultiSigWalletDepositIterator, error) { 922 923 var senderRule []interface{} 924 for _, senderItem := range sender { 925 senderRule = append(senderRule, senderItem) 926 } 927 928 logs, sub, err := _MultiSigWallet.contract.FilterLogs(opts, "Deposit", senderRule) 929 if err != nil { 930 return nil, err 931 } 932 return &MultiSigWalletDepositIterator{contract: _MultiSigWallet.contract, event: "Deposit", logs: logs, sub: sub}, nil 933 } 934 935 // WatchDeposit is a free log subscription operation binding the contract event 0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c. 936 // 937 // Solidity: event Deposit(sender indexed address, value uint256) 938 func (_MultiSigWallet *MultiSigWalletFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *MultiSigWalletDeposit, sender []common.Address) (event.Subscription, error) { 939 940 var senderRule []interface{} 941 for _, senderItem := range sender { 942 senderRule = append(senderRule, senderItem) 943 } 944 945 logs, sub, err := _MultiSigWallet.contract.WatchLogs(opts, "Deposit", senderRule) 946 if err != nil { 947 return nil, err 948 } 949 return event.NewSubscription(func(quit <-chan struct{}) error { 950 defer sub.Unsubscribe() 951 for { 952 select { 953 case log := <-logs: 954 // New log arrived, parse the event and forward to the user 955 event := new(MultiSigWalletDeposit) 956 if err := _MultiSigWallet.contract.UnpackLog(event, "Deposit", log); err != nil { 957 return err 958 } 959 event.Raw = log 960 961 select { 962 case sink <- event: 963 case err := <-sub.Err(): 964 return err 965 case <-quit: 966 return nil 967 } 968 case err := <-sub.Err(): 969 return err 970 case <-quit: 971 return nil 972 } 973 } 974 }), nil 975 } 976 977 // MultiSigWalletExecutionIterator is returned from FilterExecution and is used to iterate over the raw logs and unpacked data for Execution events raised by the MultiSigWallet contract. 978 type MultiSigWalletExecutionIterator struct { 979 Event *MultiSigWalletExecution // Event containing the contract specifics and raw log 980 981 contract *bind.BoundContract // Generic contract to use for unpacking event data 982 event string // Event name to use for unpacking event data 983 984 logs chan types.Log // Log channel receiving the found contract events 985 sub ethereum.Subscription // Subscription for errors, completion and termination 986 done bool // Whether the subscription completed delivering logs 987 fail error // Occurred error to stop iteration 988 } 989 990 // Next advances the iterator to the subsequent event, returning whether there 991 // are any more events found. In case of a retrieval or parsing error, false is 992 // returned and Error() can be queried for the exact failure. 993 func (it *MultiSigWalletExecutionIterator) Next() bool { 994 // If the iterator failed, stop iterating 995 if it.fail != nil { 996 return false 997 } 998 // If the iterator completed, deliver directly whatever's available 999 if it.done { 1000 select { 1001 case log := <-it.logs: 1002 it.Event = new(MultiSigWalletExecution) 1003 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1004 it.fail = err 1005 return false 1006 } 1007 it.Event.Raw = log 1008 return true 1009 1010 default: 1011 return false 1012 } 1013 } 1014 // Iterator still in progress, wait for either a data or an error event 1015 select { 1016 case log := <-it.logs: 1017 it.Event = new(MultiSigWalletExecution) 1018 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1019 it.fail = err 1020 return false 1021 } 1022 it.Event.Raw = log 1023 return true 1024 1025 case err := <-it.sub.Err(): 1026 it.done = true 1027 it.fail = err 1028 return it.Next() 1029 } 1030 } 1031 1032 // Error returns any retrieval or parsing error occurred during filtering. 1033 func (it *MultiSigWalletExecutionIterator) Error() error { 1034 return it.fail 1035 } 1036 1037 // Close terminates the iteration process, releasing any pending underlying 1038 // resources. 1039 func (it *MultiSigWalletExecutionIterator) Close() error { 1040 it.sub.Unsubscribe() 1041 return nil 1042 } 1043 1044 // MultiSigWalletExecution represents a Execution event raised by the MultiSigWallet contract. 1045 type MultiSigWalletExecution struct { 1046 TransactionId *big.Int 1047 Raw types.Log // Blockchain specific contextual infos 1048 } 1049 1050 // FilterExecution is a free log retrieval operation binding the contract event 0x33e13ecb54c3076d8e8bb8c2881800a4d972b792045ffae98fdf46df365fed75. 1051 // 1052 // Solidity: event Execution(transactionId indexed uint256) 1053 func (_MultiSigWallet *MultiSigWalletFilterer) FilterExecution(opts *bind.FilterOpts, transactionId []*big.Int) (*MultiSigWalletExecutionIterator, error) { 1054 1055 var transactionIdRule []interface{} 1056 for _, transactionIdItem := range transactionId { 1057 transactionIdRule = append(transactionIdRule, transactionIdItem) 1058 } 1059 1060 logs, sub, err := _MultiSigWallet.contract.FilterLogs(opts, "Execution", transactionIdRule) 1061 if err != nil { 1062 return nil, err 1063 } 1064 return &MultiSigWalletExecutionIterator{contract: _MultiSigWallet.contract, event: "Execution", logs: logs, sub: sub}, nil 1065 } 1066 1067 // WatchExecution is a free log subscription operation binding the contract event 0x33e13ecb54c3076d8e8bb8c2881800a4d972b792045ffae98fdf46df365fed75. 1068 // 1069 // Solidity: event Execution(transactionId indexed uint256) 1070 func (_MultiSigWallet *MultiSigWalletFilterer) WatchExecution(opts *bind.WatchOpts, sink chan<- *MultiSigWalletExecution, transactionId []*big.Int) (event.Subscription, error) { 1071 1072 var transactionIdRule []interface{} 1073 for _, transactionIdItem := range transactionId { 1074 transactionIdRule = append(transactionIdRule, transactionIdItem) 1075 } 1076 1077 logs, sub, err := _MultiSigWallet.contract.WatchLogs(opts, "Execution", transactionIdRule) 1078 if err != nil { 1079 return nil, err 1080 } 1081 return event.NewSubscription(func(quit <-chan struct{}) error { 1082 defer sub.Unsubscribe() 1083 for { 1084 select { 1085 case log := <-logs: 1086 // New log arrived, parse the event and forward to the user 1087 event := new(MultiSigWalletExecution) 1088 if err := _MultiSigWallet.contract.UnpackLog(event, "Execution", log); err != nil { 1089 return err 1090 } 1091 event.Raw = log 1092 1093 select { 1094 case sink <- event: 1095 case err := <-sub.Err(): 1096 return err 1097 case <-quit: 1098 return nil 1099 } 1100 case err := <-sub.Err(): 1101 return err 1102 case <-quit: 1103 return nil 1104 } 1105 } 1106 }), nil 1107 } 1108 1109 // MultiSigWalletExecutionFailureIterator is returned from FilterExecutionFailure and is used to iterate over the raw logs and unpacked data for ExecutionFailure events raised by the MultiSigWallet contract. 1110 type MultiSigWalletExecutionFailureIterator struct { 1111 Event *MultiSigWalletExecutionFailure // Event containing the contract specifics and raw log 1112 1113 contract *bind.BoundContract // Generic contract to use for unpacking event data 1114 event string // Event name to use for unpacking event data 1115 1116 logs chan types.Log // Log channel receiving the found contract events 1117 sub ethereum.Subscription // Subscription for errors, completion and termination 1118 done bool // Whether the subscription completed delivering logs 1119 fail error // Occurred error to stop iteration 1120 } 1121 1122 // Next advances the iterator to the subsequent event, returning whether there 1123 // are any more events found. In case of a retrieval or parsing error, false is 1124 // returned and Error() can be queried for the exact failure. 1125 func (it *MultiSigWalletExecutionFailureIterator) Next() bool { 1126 // If the iterator failed, stop iterating 1127 if it.fail != nil { 1128 return false 1129 } 1130 // If the iterator completed, deliver directly whatever's available 1131 if it.done { 1132 select { 1133 case log := <-it.logs: 1134 it.Event = new(MultiSigWalletExecutionFailure) 1135 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1136 it.fail = err 1137 return false 1138 } 1139 it.Event.Raw = log 1140 return true 1141 1142 default: 1143 return false 1144 } 1145 } 1146 // Iterator still in progress, wait for either a data or an error event 1147 select { 1148 case log := <-it.logs: 1149 it.Event = new(MultiSigWalletExecutionFailure) 1150 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1151 it.fail = err 1152 return false 1153 } 1154 it.Event.Raw = log 1155 return true 1156 1157 case err := <-it.sub.Err(): 1158 it.done = true 1159 it.fail = err 1160 return it.Next() 1161 } 1162 } 1163 1164 // Error returns any retrieval or parsing error occurred during filtering. 1165 func (it *MultiSigWalletExecutionFailureIterator) Error() error { 1166 return it.fail 1167 } 1168 1169 // Close terminates the iteration process, releasing any pending underlying 1170 // resources. 1171 func (it *MultiSigWalletExecutionFailureIterator) Close() error { 1172 it.sub.Unsubscribe() 1173 return nil 1174 } 1175 1176 // MultiSigWalletExecutionFailure represents a ExecutionFailure event raised by the MultiSigWallet contract. 1177 type MultiSigWalletExecutionFailure struct { 1178 TransactionId *big.Int 1179 Raw types.Log // Blockchain specific contextual infos 1180 } 1181 1182 // FilterExecutionFailure is a free log retrieval operation binding the contract event 0x526441bb6c1aba3c9a4a6ca1d6545da9c2333c8c48343ef398eb858d72b79236. 1183 // 1184 // Solidity: event ExecutionFailure(transactionId indexed uint256) 1185 func (_MultiSigWallet *MultiSigWalletFilterer) FilterExecutionFailure(opts *bind.FilterOpts, transactionId []*big.Int) (*MultiSigWalletExecutionFailureIterator, error) { 1186 1187 var transactionIdRule []interface{} 1188 for _, transactionIdItem := range transactionId { 1189 transactionIdRule = append(transactionIdRule, transactionIdItem) 1190 } 1191 1192 logs, sub, err := _MultiSigWallet.contract.FilterLogs(opts, "ExecutionFailure", transactionIdRule) 1193 if err != nil { 1194 return nil, err 1195 } 1196 return &MultiSigWalletExecutionFailureIterator{contract: _MultiSigWallet.contract, event: "ExecutionFailure", logs: logs, sub: sub}, nil 1197 } 1198 1199 // WatchExecutionFailure is a free log subscription operation binding the contract event 0x526441bb6c1aba3c9a4a6ca1d6545da9c2333c8c48343ef398eb858d72b79236. 1200 // 1201 // Solidity: event ExecutionFailure(transactionId indexed uint256) 1202 func (_MultiSigWallet *MultiSigWalletFilterer) WatchExecutionFailure(opts *bind.WatchOpts, sink chan<- *MultiSigWalletExecutionFailure, transactionId []*big.Int) (event.Subscription, error) { 1203 1204 var transactionIdRule []interface{} 1205 for _, transactionIdItem := range transactionId { 1206 transactionIdRule = append(transactionIdRule, transactionIdItem) 1207 } 1208 1209 logs, sub, err := _MultiSigWallet.contract.WatchLogs(opts, "ExecutionFailure", transactionIdRule) 1210 if err != nil { 1211 return nil, err 1212 } 1213 return event.NewSubscription(func(quit <-chan struct{}) error { 1214 defer sub.Unsubscribe() 1215 for { 1216 select { 1217 case log := <-logs: 1218 // New log arrived, parse the event and forward to the user 1219 event := new(MultiSigWalletExecutionFailure) 1220 if err := _MultiSigWallet.contract.UnpackLog(event, "ExecutionFailure", log); err != nil { 1221 return err 1222 } 1223 event.Raw = log 1224 1225 select { 1226 case sink <- event: 1227 case err := <-sub.Err(): 1228 return err 1229 case <-quit: 1230 return nil 1231 } 1232 case err := <-sub.Err(): 1233 return err 1234 case <-quit: 1235 return nil 1236 } 1237 } 1238 }), nil 1239 } 1240 1241 // MultiSigWalletOwnerAdditionIterator is returned from FilterOwnerAddition and is used to iterate over the raw logs and unpacked data for OwnerAddition events raised by the MultiSigWallet contract. 1242 type MultiSigWalletOwnerAdditionIterator struct { 1243 Event *MultiSigWalletOwnerAddition // Event containing the contract specifics and raw log 1244 1245 contract *bind.BoundContract // Generic contract to use for unpacking event data 1246 event string // Event name to use for unpacking event data 1247 1248 logs chan types.Log // Log channel receiving the found contract events 1249 sub ethereum.Subscription // Subscription for errors, completion and termination 1250 done bool // Whether the subscription completed delivering logs 1251 fail error // Occurred error to stop iteration 1252 } 1253 1254 // Next advances the iterator to the subsequent event, returning whether there 1255 // are any more events found. In case of a retrieval or parsing error, false is 1256 // returned and Error() can be queried for the exact failure. 1257 func (it *MultiSigWalletOwnerAdditionIterator) Next() bool { 1258 // If the iterator failed, stop iterating 1259 if it.fail != nil { 1260 return false 1261 } 1262 // If the iterator completed, deliver directly whatever's available 1263 if it.done { 1264 select { 1265 case log := <-it.logs: 1266 it.Event = new(MultiSigWalletOwnerAddition) 1267 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1268 it.fail = err 1269 return false 1270 } 1271 it.Event.Raw = log 1272 return true 1273 1274 default: 1275 return false 1276 } 1277 } 1278 // Iterator still in progress, wait for either a data or an error event 1279 select { 1280 case log := <-it.logs: 1281 it.Event = new(MultiSigWalletOwnerAddition) 1282 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1283 it.fail = err 1284 return false 1285 } 1286 it.Event.Raw = log 1287 return true 1288 1289 case err := <-it.sub.Err(): 1290 it.done = true 1291 it.fail = err 1292 return it.Next() 1293 } 1294 } 1295 1296 // Error returns any retrieval or parsing error occurred during filtering. 1297 func (it *MultiSigWalletOwnerAdditionIterator) Error() error { 1298 return it.fail 1299 } 1300 1301 // Close terminates the iteration process, releasing any pending underlying 1302 // resources. 1303 func (it *MultiSigWalletOwnerAdditionIterator) Close() error { 1304 it.sub.Unsubscribe() 1305 return nil 1306 } 1307 1308 // MultiSigWalletOwnerAddition represents a OwnerAddition event raised by the MultiSigWallet contract. 1309 type MultiSigWalletOwnerAddition struct { 1310 Owner common.Address 1311 Raw types.Log // Blockchain specific contextual infos 1312 } 1313 1314 // FilterOwnerAddition is a free log retrieval operation binding the contract event 0xf39e6e1eb0edcf53c221607b54b00cd28f3196fed0a24994dc308b8f611b682d. 1315 // 1316 // Solidity: event OwnerAddition(owner indexed address) 1317 func (_MultiSigWallet *MultiSigWalletFilterer) FilterOwnerAddition(opts *bind.FilterOpts, owner []common.Address) (*MultiSigWalletOwnerAdditionIterator, error) { 1318 1319 var ownerRule []interface{} 1320 for _, ownerItem := range owner { 1321 ownerRule = append(ownerRule, ownerItem) 1322 } 1323 1324 logs, sub, err := _MultiSigWallet.contract.FilterLogs(opts, "OwnerAddition", ownerRule) 1325 if err != nil { 1326 return nil, err 1327 } 1328 return &MultiSigWalletOwnerAdditionIterator{contract: _MultiSigWallet.contract, event: "OwnerAddition", logs: logs, sub: sub}, nil 1329 } 1330 1331 // WatchOwnerAddition is a free log subscription operation binding the contract event 0xf39e6e1eb0edcf53c221607b54b00cd28f3196fed0a24994dc308b8f611b682d. 1332 // 1333 // Solidity: event OwnerAddition(owner indexed address) 1334 func (_MultiSigWallet *MultiSigWalletFilterer) WatchOwnerAddition(opts *bind.WatchOpts, sink chan<- *MultiSigWalletOwnerAddition, owner []common.Address) (event.Subscription, error) { 1335 1336 var ownerRule []interface{} 1337 for _, ownerItem := range owner { 1338 ownerRule = append(ownerRule, ownerItem) 1339 } 1340 1341 logs, sub, err := _MultiSigWallet.contract.WatchLogs(opts, "OwnerAddition", ownerRule) 1342 if err != nil { 1343 return nil, err 1344 } 1345 return event.NewSubscription(func(quit <-chan struct{}) error { 1346 defer sub.Unsubscribe() 1347 for { 1348 select { 1349 case log := <-logs: 1350 // New log arrived, parse the event and forward to the user 1351 event := new(MultiSigWalletOwnerAddition) 1352 if err := _MultiSigWallet.contract.UnpackLog(event, "OwnerAddition", log); err != nil { 1353 return err 1354 } 1355 event.Raw = log 1356 1357 select { 1358 case sink <- event: 1359 case err := <-sub.Err(): 1360 return err 1361 case <-quit: 1362 return nil 1363 } 1364 case err := <-sub.Err(): 1365 return err 1366 case <-quit: 1367 return nil 1368 } 1369 } 1370 }), nil 1371 } 1372 1373 // MultiSigWalletOwnerRemovalIterator is returned from FilterOwnerRemoval and is used to iterate over the raw logs and unpacked data for OwnerRemoval events raised by the MultiSigWallet contract. 1374 type MultiSigWalletOwnerRemovalIterator struct { 1375 Event *MultiSigWalletOwnerRemoval // Event containing the contract specifics and raw log 1376 1377 contract *bind.BoundContract // Generic contract to use for unpacking event data 1378 event string // Event name to use for unpacking event data 1379 1380 logs chan types.Log // Log channel receiving the found contract events 1381 sub ethereum.Subscription // Subscription for errors, completion and termination 1382 done bool // Whether the subscription completed delivering logs 1383 fail error // Occurred error to stop iteration 1384 } 1385 1386 // Next advances the iterator to the subsequent event, returning whether there 1387 // are any more events found. In case of a retrieval or parsing error, false is 1388 // returned and Error() can be queried for the exact failure. 1389 func (it *MultiSigWalletOwnerRemovalIterator) Next() bool { 1390 // If the iterator failed, stop iterating 1391 if it.fail != nil { 1392 return false 1393 } 1394 // If the iterator completed, deliver directly whatever's available 1395 if it.done { 1396 select { 1397 case log := <-it.logs: 1398 it.Event = new(MultiSigWalletOwnerRemoval) 1399 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1400 it.fail = err 1401 return false 1402 } 1403 it.Event.Raw = log 1404 return true 1405 1406 default: 1407 return false 1408 } 1409 } 1410 // Iterator still in progress, wait for either a data or an error event 1411 select { 1412 case log := <-it.logs: 1413 it.Event = new(MultiSigWalletOwnerRemoval) 1414 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1415 it.fail = err 1416 return false 1417 } 1418 it.Event.Raw = log 1419 return true 1420 1421 case err := <-it.sub.Err(): 1422 it.done = true 1423 it.fail = err 1424 return it.Next() 1425 } 1426 } 1427 1428 // Error returns any retrieval or parsing error occurred during filtering. 1429 func (it *MultiSigWalletOwnerRemovalIterator) Error() error { 1430 return it.fail 1431 } 1432 1433 // Close terminates the iteration process, releasing any pending underlying 1434 // resources. 1435 func (it *MultiSigWalletOwnerRemovalIterator) Close() error { 1436 it.sub.Unsubscribe() 1437 return nil 1438 } 1439 1440 // MultiSigWalletOwnerRemoval represents a OwnerRemoval event raised by the MultiSigWallet contract. 1441 type MultiSigWalletOwnerRemoval struct { 1442 Owner common.Address 1443 Raw types.Log // Blockchain specific contextual infos 1444 } 1445 1446 // FilterOwnerRemoval is a free log retrieval operation binding the contract event 0x8001553a916ef2f495d26a907cc54d96ed840d7bda71e73194bf5a9df7a76b90. 1447 // 1448 // Solidity: event OwnerRemoval(owner indexed address) 1449 func (_MultiSigWallet *MultiSigWalletFilterer) FilterOwnerRemoval(opts *bind.FilterOpts, owner []common.Address) (*MultiSigWalletOwnerRemovalIterator, error) { 1450 1451 var ownerRule []interface{} 1452 for _, ownerItem := range owner { 1453 ownerRule = append(ownerRule, ownerItem) 1454 } 1455 1456 logs, sub, err := _MultiSigWallet.contract.FilterLogs(opts, "OwnerRemoval", ownerRule) 1457 if err != nil { 1458 return nil, err 1459 } 1460 return &MultiSigWalletOwnerRemovalIterator{contract: _MultiSigWallet.contract, event: "OwnerRemoval", logs: logs, sub: sub}, nil 1461 } 1462 1463 // WatchOwnerRemoval is a free log subscription operation binding the contract event 0x8001553a916ef2f495d26a907cc54d96ed840d7bda71e73194bf5a9df7a76b90. 1464 // 1465 // Solidity: event OwnerRemoval(owner indexed address) 1466 func (_MultiSigWallet *MultiSigWalletFilterer) WatchOwnerRemoval(opts *bind.WatchOpts, sink chan<- *MultiSigWalletOwnerRemoval, owner []common.Address) (event.Subscription, error) { 1467 1468 var ownerRule []interface{} 1469 for _, ownerItem := range owner { 1470 ownerRule = append(ownerRule, ownerItem) 1471 } 1472 1473 logs, sub, err := _MultiSigWallet.contract.WatchLogs(opts, "OwnerRemoval", ownerRule) 1474 if err != nil { 1475 return nil, err 1476 } 1477 return event.NewSubscription(func(quit <-chan struct{}) error { 1478 defer sub.Unsubscribe() 1479 for { 1480 select { 1481 case log := <-logs: 1482 // New log arrived, parse the event and forward to the user 1483 event := new(MultiSigWalletOwnerRemoval) 1484 if err := _MultiSigWallet.contract.UnpackLog(event, "OwnerRemoval", log); err != nil { 1485 return err 1486 } 1487 event.Raw = log 1488 1489 select { 1490 case sink <- event: 1491 case err := <-sub.Err(): 1492 return err 1493 case <-quit: 1494 return nil 1495 } 1496 case err := <-sub.Err(): 1497 return err 1498 case <-quit: 1499 return nil 1500 } 1501 } 1502 }), nil 1503 } 1504 1505 // MultiSigWalletRequirementChangeIterator is returned from FilterRequirementChange and is used to iterate over the raw logs and unpacked data for RequirementChange events raised by the MultiSigWallet contract. 1506 type MultiSigWalletRequirementChangeIterator struct { 1507 Event *MultiSigWalletRequirementChange // Event containing the contract specifics and raw log 1508 1509 contract *bind.BoundContract // Generic contract to use for unpacking event data 1510 event string // Event name to use for unpacking event data 1511 1512 logs chan types.Log // Log channel receiving the found contract events 1513 sub ethereum.Subscription // Subscription for errors, completion and termination 1514 done bool // Whether the subscription completed delivering logs 1515 fail error // Occurred error to stop iteration 1516 } 1517 1518 // Next advances the iterator to the subsequent event, returning whether there 1519 // are any more events found. In case of a retrieval or parsing error, false is 1520 // returned and Error() can be queried for the exact failure. 1521 func (it *MultiSigWalletRequirementChangeIterator) Next() bool { 1522 // If the iterator failed, stop iterating 1523 if it.fail != nil { 1524 return false 1525 } 1526 // If the iterator completed, deliver directly whatever's available 1527 if it.done { 1528 select { 1529 case log := <-it.logs: 1530 it.Event = new(MultiSigWalletRequirementChange) 1531 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1532 it.fail = err 1533 return false 1534 } 1535 it.Event.Raw = log 1536 return true 1537 1538 default: 1539 return false 1540 } 1541 } 1542 // Iterator still in progress, wait for either a data or an error event 1543 select { 1544 case log := <-it.logs: 1545 it.Event = new(MultiSigWalletRequirementChange) 1546 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1547 it.fail = err 1548 return false 1549 } 1550 it.Event.Raw = log 1551 return true 1552 1553 case err := <-it.sub.Err(): 1554 it.done = true 1555 it.fail = err 1556 return it.Next() 1557 } 1558 } 1559 1560 // Error returns any retrieval or parsing error occurred during filtering. 1561 func (it *MultiSigWalletRequirementChangeIterator) Error() error { 1562 return it.fail 1563 } 1564 1565 // Close terminates the iteration process, releasing any pending underlying 1566 // resources. 1567 func (it *MultiSigWalletRequirementChangeIterator) Close() error { 1568 it.sub.Unsubscribe() 1569 return nil 1570 } 1571 1572 // MultiSigWalletRequirementChange represents a RequirementChange event raised by the MultiSigWallet contract. 1573 type MultiSigWalletRequirementChange struct { 1574 Required *big.Int 1575 Raw types.Log // Blockchain specific contextual infos 1576 } 1577 1578 // FilterRequirementChange is a free log retrieval operation binding the contract event 0xa3f1ee9126a074d9326c682f561767f710e927faa811f7a99829d49dc421797a. 1579 // 1580 // Solidity: event RequirementChange(required uint256) 1581 func (_MultiSigWallet *MultiSigWalletFilterer) FilterRequirementChange(opts *bind.FilterOpts) (*MultiSigWalletRequirementChangeIterator, error) { 1582 1583 logs, sub, err := _MultiSigWallet.contract.FilterLogs(opts, "RequirementChange") 1584 if err != nil { 1585 return nil, err 1586 } 1587 return &MultiSigWalletRequirementChangeIterator{contract: _MultiSigWallet.contract, event: "RequirementChange", logs: logs, sub: sub}, nil 1588 } 1589 1590 // WatchRequirementChange is a free log subscription operation binding the contract event 0xa3f1ee9126a074d9326c682f561767f710e927faa811f7a99829d49dc421797a. 1591 // 1592 // Solidity: event RequirementChange(required uint256) 1593 func (_MultiSigWallet *MultiSigWalletFilterer) WatchRequirementChange(opts *bind.WatchOpts, sink chan<- *MultiSigWalletRequirementChange) (event.Subscription, error) { 1594 1595 logs, sub, err := _MultiSigWallet.contract.WatchLogs(opts, "RequirementChange") 1596 if err != nil { 1597 return nil, err 1598 } 1599 return event.NewSubscription(func(quit <-chan struct{}) error { 1600 defer sub.Unsubscribe() 1601 for { 1602 select { 1603 case log := <-logs: 1604 // New log arrived, parse the event and forward to the user 1605 event := new(MultiSigWalletRequirementChange) 1606 if err := _MultiSigWallet.contract.UnpackLog(event, "RequirementChange", log); err != nil { 1607 return err 1608 } 1609 event.Raw = log 1610 1611 select { 1612 case sink <- event: 1613 case err := <-sub.Err(): 1614 return err 1615 case <-quit: 1616 return nil 1617 } 1618 case err := <-sub.Err(): 1619 return err 1620 case <-quit: 1621 return nil 1622 } 1623 } 1624 }), nil 1625 } 1626 1627 // MultiSigWalletRevocationIterator is returned from FilterRevocation and is used to iterate over the raw logs and unpacked data for Revocation events raised by the MultiSigWallet contract. 1628 type MultiSigWalletRevocationIterator struct { 1629 Event *MultiSigWalletRevocation // Event containing the contract specifics and raw log 1630 1631 contract *bind.BoundContract // Generic contract to use for unpacking event data 1632 event string // Event name to use for unpacking event data 1633 1634 logs chan types.Log // Log channel receiving the found contract events 1635 sub ethereum.Subscription // Subscription for errors, completion and termination 1636 done bool // Whether the subscription completed delivering logs 1637 fail error // Occurred error to stop iteration 1638 } 1639 1640 // Next advances the iterator to the subsequent event, returning whether there 1641 // are any more events found. In case of a retrieval or parsing error, false is 1642 // returned and Error() can be queried for the exact failure. 1643 func (it *MultiSigWalletRevocationIterator) Next() bool { 1644 // If the iterator failed, stop iterating 1645 if it.fail != nil { 1646 return false 1647 } 1648 // If the iterator completed, deliver directly whatever's available 1649 if it.done { 1650 select { 1651 case log := <-it.logs: 1652 it.Event = new(MultiSigWalletRevocation) 1653 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1654 it.fail = err 1655 return false 1656 } 1657 it.Event.Raw = log 1658 return true 1659 1660 default: 1661 return false 1662 } 1663 } 1664 // Iterator still in progress, wait for either a data or an error event 1665 select { 1666 case log := <-it.logs: 1667 it.Event = new(MultiSigWalletRevocation) 1668 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1669 it.fail = err 1670 return false 1671 } 1672 it.Event.Raw = log 1673 return true 1674 1675 case err := <-it.sub.Err(): 1676 it.done = true 1677 it.fail = err 1678 return it.Next() 1679 } 1680 } 1681 1682 // Error returns any retrieval or parsing error occurred during filtering. 1683 func (it *MultiSigWalletRevocationIterator) Error() error { 1684 return it.fail 1685 } 1686 1687 // Close terminates the iteration process, releasing any pending underlying 1688 // resources. 1689 func (it *MultiSigWalletRevocationIterator) Close() error { 1690 it.sub.Unsubscribe() 1691 return nil 1692 } 1693 1694 // MultiSigWalletRevocation represents a Revocation event raised by the MultiSigWallet contract. 1695 type MultiSigWalletRevocation struct { 1696 Sender common.Address 1697 TransactionId *big.Int 1698 Raw types.Log // Blockchain specific contextual infos 1699 } 1700 1701 // FilterRevocation is a free log retrieval operation binding the contract event 0xf6a317157440607f36269043eb55f1287a5a19ba2216afeab88cd46cbcfb88e9. 1702 // 1703 // Solidity: event Revocation(sender indexed address, transactionId indexed uint256) 1704 func (_MultiSigWallet *MultiSigWalletFilterer) FilterRevocation(opts *bind.FilterOpts, sender []common.Address, transactionId []*big.Int) (*MultiSigWalletRevocationIterator, error) { 1705 1706 var senderRule []interface{} 1707 for _, senderItem := range sender { 1708 senderRule = append(senderRule, senderItem) 1709 } 1710 var transactionIdRule []interface{} 1711 for _, transactionIdItem := range transactionId { 1712 transactionIdRule = append(transactionIdRule, transactionIdItem) 1713 } 1714 1715 logs, sub, err := _MultiSigWallet.contract.FilterLogs(opts, "Revocation", senderRule, transactionIdRule) 1716 if err != nil { 1717 return nil, err 1718 } 1719 return &MultiSigWalletRevocationIterator{contract: _MultiSigWallet.contract, event: "Revocation", logs: logs, sub: sub}, nil 1720 } 1721 1722 // WatchRevocation is a free log subscription operation binding the contract event 0xf6a317157440607f36269043eb55f1287a5a19ba2216afeab88cd46cbcfb88e9. 1723 // 1724 // Solidity: event Revocation(sender indexed address, transactionId indexed uint256) 1725 func (_MultiSigWallet *MultiSigWalletFilterer) WatchRevocation(opts *bind.WatchOpts, sink chan<- *MultiSigWalletRevocation, sender []common.Address, transactionId []*big.Int) (event.Subscription, error) { 1726 1727 var senderRule []interface{} 1728 for _, senderItem := range sender { 1729 senderRule = append(senderRule, senderItem) 1730 } 1731 var transactionIdRule []interface{} 1732 for _, transactionIdItem := range transactionId { 1733 transactionIdRule = append(transactionIdRule, transactionIdItem) 1734 } 1735 1736 logs, sub, err := _MultiSigWallet.contract.WatchLogs(opts, "Revocation", senderRule, transactionIdRule) 1737 if err != nil { 1738 return nil, err 1739 } 1740 return event.NewSubscription(func(quit <-chan struct{}) error { 1741 defer sub.Unsubscribe() 1742 for { 1743 select { 1744 case log := <-logs: 1745 // New log arrived, parse the event and forward to the user 1746 event := new(MultiSigWalletRevocation) 1747 if err := _MultiSigWallet.contract.UnpackLog(event, "Revocation", log); err != nil { 1748 return err 1749 } 1750 event.Raw = log 1751 1752 select { 1753 case sink <- event: 1754 case err := <-sub.Err(): 1755 return err 1756 case <-quit: 1757 return nil 1758 } 1759 case err := <-sub.Err(): 1760 return err 1761 case <-quit: 1762 return nil 1763 } 1764 } 1765 }), nil 1766 } 1767 1768 // MultiSigWalletSubmissionIterator is returned from FilterSubmission and is used to iterate over the raw logs and unpacked data for Submission events raised by the MultiSigWallet contract. 1769 type MultiSigWalletSubmissionIterator struct { 1770 Event *MultiSigWalletSubmission // Event containing the contract specifics and raw log 1771 1772 contract *bind.BoundContract // Generic contract to use for unpacking event data 1773 event string // Event name to use for unpacking event data 1774 1775 logs chan types.Log // Log channel receiving the found contract events 1776 sub ethereum.Subscription // Subscription for errors, completion and termination 1777 done bool // Whether the subscription completed delivering logs 1778 fail error // Occurred error to stop iteration 1779 } 1780 1781 // Next advances the iterator to the subsequent event, returning whether there 1782 // are any more events found. In case of a retrieval or parsing error, false is 1783 // returned and Error() can be queried for the exact failure. 1784 func (it *MultiSigWalletSubmissionIterator) Next() bool { 1785 // If the iterator failed, stop iterating 1786 if it.fail != nil { 1787 return false 1788 } 1789 // If the iterator completed, deliver directly whatever's available 1790 if it.done { 1791 select { 1792 case log := <-it.logs: 1793 it.Event = new(MultiSigWalletSubmission) 1794 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1795 it.fail = err 1796 return false 1797 } 1798 it.Event.Raw = log 1799 return true 1800 1801 default: 1802 return false 1803 } 1804 } 1805 // Iterator still in progress, wait for either a data or an error event 1806 select { 1807 case log := <-it.logs: 1808 it.Event = new(MultiSigWalletSubmission) 1809 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1810 it.fail = err 1811 return false 1812 } 1813 it.Event.Raw = log 1814 return true 1815 1816 case err := <-it.sub.Err(): 1817 it.done = true 1818 it.fail = err 1819 return it.Next() 1820 } 1821 } 1822 1823 // Error returns any retrieval or parsing error occurred during filtering. 1824 func (it *MultiSigWalletSubmissionIterator) Error() error { 1825 return it.fail 1826 } 1827 1828 // Close terminates the iteration process, releasing any pending underlying 1829 // resources. 1830 func (it *MultiSigWalletSubmissionIterator) Close() error { 1831 it.sub.Unsubscribe() 1832 return nil 1833 } 1834 1835 // MultiSigWalletSubmission represents a Submission event raised by the MultiSigWallet contract. 1836 type MultiSigWalletSubmission struct { 1837 TransactionId *big.Int 1838 Raw types.Log // Blockchain specific contextual infos 1839 } 1840 1841 // FilterSubmission is a free log retrieval operation binding the contract event 0xc0ba8fe4b176c1714197d43b9cc6bcf797a4a7461c5fe8d0ef6e184ae7601e51. 1842 // 1843 // Solidity: event Submission(transactionId indexed uint256) 1844 func (_MultiSigWallet *MultiSigWalletFilterer) FilterSubmission(opts *bind.FilterOpts, transactionId []*big.Int) (*MultiSigWalletSubmissionIterator, error) { 1845 1846 var transactionIdRule []interface{} 1847 for _, transactionIdItem := range transactionId { 1848 transactionIdRule = append(transactionIdRule, transactionIdItem) 1849 } 1850 1851 logs, sub, err := _MultiSigWallet.contract.FilterLogs(opts, "Submission", transactionIdRule) 1852 if err != nil { 1853 return nil, err 1854 } 1855 return &MultiSigWalletSubmissionIterator{contract: _MultiSigWallet.contract, event: "Submission", logs: logs, sub: sub}, nil 1856 } 1857 1858 // WatchSubmission is a free log subscription operation binding the contract event 0xc0ba8fe4b176c1714197d43b9cc6bcf797a4a7461c5fe8d0ef6e184ae7601e51. 1859 // 1860 // Solidity: event Submission(transactionId indexed uint256) 1861 func (_MultiSigWallet *MultiSigWalletFilterer) WatchSubmission(opts *bind.WatchOpts, sink chan<- *MultiSigWalletSubmission, transactionId []*big.Int) (event.Subscription, error) { 1862 1863 var transactionIdRule []interface{} 1864 for _, transactionIdItem := range transactionId { 1865 transactionIdRule = append(transactionIdRule, transactionIdItem) 1866 } 1867 1868 logs, sub, err := _MultiSigWallet.contract.WatchLogs(opts, "Submission", transactionIdRule) 1869 if err != nil { 1870 return nil, err 1871 } 1872 return event.NewSubscription(func(quit <-chan struct{}) error { 1873 defer sub.Unsubscribe() 1874 for { 1875 select { 1876 case log := <-logs: 1877 // New log arrived, parse the event and forward to the user 1878 event := new(MultiSigWalletSubmission) 1879 if err := _MultiSigWallet.contract.UnpackLog(event, "Submission", log); err != nil { 1880 return err 1881 } 1882 event.Raw = log 1883 1884 select { 1885 case sink <- event: 1886 case err := <-sub.Err(): 1887 return err 1888 case <-quit: 1889 return nil 1890 } 1891 case err := <-sub.Err(): 1892 return err 1893 case <-quit: 1894 return nil 1895 } 1896 } 1897 }), nil 1898 }