// Code generated - DO NOT EDIT. // This file is a generated binding and any manual changes will be lost. package contract import ( "math/big" "strings" ethereum "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/event" ) // MultiSigWalletABI is the input ABI used to generate the binding from. 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\"}]" // MultiSigWalletBin is the compiled bytecode used for deploying new contracts. const MultiSigWalletBin = `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` // DeployMultiSigWallet deploys a new Ethereum contract, binding an instance of MultiSigWallet to it. func DeployMultiSigWallet(auth *bind.TransactOpts, backend bind.ContractBackend, _owners []common.Address, _required *big.Int) (common.Address, *types.Transaction, *MultiSigWallet, error) { parsed, err := abi.JSON(strings.NewReader(MultiSigWalletABI)) if err != nil { return common.Address{}, nil, nil, err } address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(MultiSigWalletBin), backend, _owners, _required) if err != nil { return common.Address{}, nil, nil, err } return address, tx, &MultiSigWallet{MultiSigWalletCaller: MultiSigWalletCaller{contract: contract}, MultiSigWalletTransactor: MultiSigWalletTransactor{contract: contract}, MultiSigWalletFilterer: MultiSigWalletFilterer{contract: contract}}, nil } // MultiSigWallet is an auto generated Go binding around an Ethereum contract. type MultiSigWallet struct { MultiSigWalletCaller // Read-only binding to the contract MultiSigWalletTransactor // Write-only binding to the contract MultiSigWalletFilterer // Log filterer for contract events } // MultiSigWalletCaller is an auto generated read-only Go binding around an Ethereum contract. type MultiSigWalletCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // MultiSigWalletTransactor is an auto generated write-only Go binding around an Ethereum contract. type MultiSigWalletTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // MultiSigWalletFilterer is an auto generated log filtering Go binding around an Ethereum contract events. type MultiSigWalletFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } // MultiSigWalletSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. type MultiSigWalletSession struct { Contract *MultiSigWallet // Generic contract binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // MultiSigWalletCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. type MultiSigWalletCallerSession struct { Contract *MultiSigWalletCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } // MultiSigWalletTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. type MultiSigWalletTransactorSession struct { Contract *MultiSigWalletTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } // MultiSigWalletRaw is an auto generated low-level Go binding around an Ethereum contract. type MultiSigWalletRaw struct { Contract *MultiSigWallet // Generic contract binding to access the raw methods on } // MultiSigWalletCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. type MultiSigWalletCallerRaw struct { Contract *MultiSigWalletCaller // Generic read-only contract binding to access the raw methods on } // MultiSigWalletTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. type MultiSigWalletTransactorRaw struct { Contract *MultiSigWalletTransactor // Generic write-only contract binding to access the raw methods on } // NewMultiSigWallet creates a new instance of MultiSigWallet, bound to a specific deployed contract. func NewMultiSigWallet(address common.Address, backend bind.ContractBackend) (*MultiSigWallet, error) { contract, err := bindMultiSigWallet(address, backend, backend, backend) if err != nil { return nil, err } return &MultiSigWallet{MultiSigWalletCaller: MultiSigWalletCaller{contract: contract}, MultiSigWalletTransactor: MultiSigWalletTransactor{contract: contract}, MultiSigWalletFilterer: MultiSigWalletFilterer{contract: contract}}, nil } // NewMultiSigWalletCaller creates a new read-only instance of MultiSigWallet, bound to a specific deployed contract. func NewMultiSigWalletCaller(address common.Address, caller bind.ContractCaller) (*MultiSigWalletCaller, error) { contract, err := bindMultiSigWallet(address, caller, nil, nil) if err != nil { return nil, err } return &MultiSigWalletCaller{contract: contract}, nil } // NewMultiSigWalletTransactor creates a new write-only instance of MultiSigWallet, bound to a specific deployed contract. func NewMultiSigWalletTransactor(address common.Address, transactor bind.ContractTransactor) (*MultiSigWalletTransactor, error) { contract, err := bindMultiSigWallet(address, nil, transactor, nil) if err != nil { return nil, err } return &MultiSigWalletTransactor{contract: contract}, nil } // NewMultiSigWalletFilterer creates a new log filterer instance of MultiSigWallet, bound to a specific deployed contract. func NewMultiSigWalletFilterer(address common.Address, filterer bind.ContractFilterer) (*MultiSigWalletFilterer, error) { contract, err := bindMultiSigWallet(address, nil, nil, filterer) if err != nil { return nil, err } return &MultiSigWalletFilterer{contract: contract}, nil } // bindMultiSigWallet binds a generic wrapper to an already deployed contract. func bindMultiSigWallet(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { parsed, err := abi.JSON(strings.NewReader(MultiSigWalletABI)) if err != nil { return nil, err } return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil } // Call invokes the (constant) contract method with params as input values and // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. func (_MultiSigWallet *MultiSigWalletRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _MultiSigWallet.Contract.MultiSigWalletCaller.contract.Call(opts, result, method, params...) } // Transfer initiates a plain transaction to move funds to the contract, calling // its default method if one is available. func (_MultiSigWallet *MultiSigWalletRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _MultiSigWallet.Contract.MultiSigWalletTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_MultiSigWallet *MultiSigWalletRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _MultiSigWallet.Contract.MultiSigWalletTransactor.contract.Transact(opts, method, params...) } // Call invokes the (constant) contract method with params as input values and // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. func (_MultiSigWallet *MultiSigWalletCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { return _MultiSigWallet.Contract.contract.Call(opts, result, method, params...) } // Transfer initiates a plain transaction to move funds to the contract, calling // its default method if one is available. func (_MultiSigWallet *MultiSigWalletTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { return _MultiSigWallet.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. func (_MultiSigWallet *MultiSigWalletTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { return _MultiSigWallet.Contract.contract.Transact(opts, method, params...) } // MAXOWNERCOUNT is a free data retrieval call binding the contract method 0xd74f8edd. // // Solidity: function MAX_OWNER_COUNT() constant returns(uint256) func (_MultiSigWallet *MultiSigWalletCaller) MAXOWNERCOUNT(opts *bind.CallOpts) (*big.Int, error) { var ( ret0 = new(*big.Int) ) out := &[]interface{}{ ret0, } err := _MultiSigWallet.contract.Call(opts, out, "MAX_OWNER_COUNT") return *ret0, err } // MAXOWNERCOUNT is a free data retrieval call binding the contract method 0xd74f8edd. // // Solidity: function MAX_OWNER_COUNT() constant returns(uint256) func (_MultiSigWallet *MultiSigWalletSession) MAXOWNERCOUNT() (*big.Int, error) { return _MultiSigWallet.Contract.MAXOWNERCOUNT(&_MultiSigWallet.CallOpts) } // MAXOWNERCOUNT is a free data retrieval call binding the contract method 0xd74f8edd. // // Solidity: function MAX_OWNER_COUNT() constant returns(uint256) func (_MultiSigWallet *MultiSigWalletCallerSession) MAXOWNERCOUNT() (*big.Int, error) { return _MultiSigWallet.Contract.MAXOWNERCOUNT(&_MultiSigWallet.CallOpts) } // Confirmations is a free data retrieval call binding the contract method 0x3411c81c. // // Solidity: function confirmations( uint256, address) constant returns(bool) func (_MultiSigWallet *MultiSigWalletCaller) Confirmations(opts *bind.CallOpts, arg0 *big.Int, arg1 common.Address) (bool, error) { var ( ret0 = new(bool) ) out := &[]interface{}{ ret0, } err := _MultiSigWallet.contract.Call(opts, out, "confirmations", arg0, arg1) return *ret0, err } // Confirmations is a free data retrieval call binding the contract method 0x3411c81c. // // Solidity: function confirmations( uint256, address) constant returns(bool) func (_MultiSigWallet *MultiSigWalletSession) Confirmations(arg0 *big.Int, arg1 common.Address) (bool, error) { return _MultiSigWallet.Contract.Confirmations(&_MultiSigWallet.CallOpts, arg0, arg1) } // Confirmations is a free data retrieval call binding the contract method 0x3411c81c. // // Solidity: function confirmations( uint256, address) constant returns(bool) func (_MultiSigWallet *MultiSigWalletCallerSession) Confirmations(arg0 *big.Int, arg1 common.Address) (bool, error) { return _MultiSigWallet.Contract.Confirmations(&_MultiSigWallet.CallOpts, arg0, arg1) } // GetConfirmationCount is a free data retrieval call binding the contract method 0x8b51d13f. // // Solidity: function getConfirmationCount(transactionId uint256) constant returns(count uint256) func (_MultiSigWallet *MultiSigWalletCaller) GetConfirmationCount(opts *bind.CallOpts, transactionId *big.Int) (*big.Int, error) { var ( ret0 = new(*big.Int) ) out := &[]interface{}{ ret0, } err := _MultiSigWallet.contract.Call(opts, out, "getConfirmationCount", transactionId) return *ret0, err } // GetConfirmationCount is a free data retrieval call binding the contract method 0x8b51d13f. // // Solidity: function getConfirmationCount(transactionId uint256) constant returns(count uint256) func (_MultiSigWallet *MultiSigWalletSession) GetConfirmationCount(transactionId *big.Int) (*big.Int, error) { return _MultiSigWallet.Contract.GetConfirmationCount(&_MultiSigWallet.CallOpts, transactionId) } // GetConfirmationCount is a free data retrieval call binding the contract method 0x8b51d13f. // // Solidity: function getConfirmationCount(transactionId uint256) constant returns(count uint256) func (_MultiSigWallet *MultiSigWalletCallerSession) GetConfirmationCount(transactionId *big.Int) (*big.Int, error) { return _MultiSigWallet.Contract.GetConfirmationCount(&_MultiSigWallet.CallOpts, transactionId) } // GetConfirmations is a free data retrieval call binding the contract method 0xb5dc40c3. // // Solidity: function getConfirmations(transactionId uint256) constant returns(_confirmations address[]) func (_MultiSigWallet *MultiSigWalletCaller) GetConfirmations(opts *bind.CallOpts, transactionId *big.Int) ([]common.Address, error) { var ( ret0 = new([]common.Address) ) out := &[]interface{}{ ret0, } err := _MultiSigWallet.contract.Call(opts, out, "getConfirmations", transactionId) return *ret0, err } // GetConfirmations is a free data retrieval call binding the contract method 0xb5dc40c3. // // Solidity: function getConfirmations(transactionId uint256) constant returns(_confirmations address[]) func (_MultiSigWallet *MultiSigWalletSession) GetConfirmations(transactionId *big.Int) ([]common.Address, error) { return _MultiSigWallet.Contract.GetConfirmations(&_MultiSigWallet.CallOpts, transactionId) } // GetConfirmations is a free data retrieval call binding the contract method 0xb5dc40c3. // // Solidity: function getConfirmations(transactionId uint256) constant returns(_confirmations address[]) func (_MultiSigWallet *MultiSigWalletCallerSession) GetConfirmations(transactionId *big.Int) ([]common.Address, error) { return _MultiSigWallet.Contract.GetConfirmations(&_MultiSigWallet.CallOpts, transactionId) } // GetOwners is a free data retrieval call binding the contract method 0xa0e67e2b. // // Solidity: function getOwners() constant returns(address[]) func (_MultiSigWallet *MultiSigWalletCaller) GetOwners(opts *bind.CallOpts) ([]common.Address, error) { var ( ret0 = new([]common.Address) ) out := &[]interface{}{ ret0, } err := _MultiSigWallet.contract.Call(opts, out, "getOwners") return *ret0, err } // GetOwners is a free data retrieval call binding the contract method 0xa0e67e2b. // // Solidity: function getOwners() constant returns(address[]) func (_MultiSigWallet *MultiSigWalletSession) GetOwners() ([]common.Address, error) { return _MultiSigWallet.Contract.GetOwners(&_MultiSigWallet.CallOpts) } // GetOwners is a free data retrieval call binding the contract method 0xa0e67e2b. // // Solidity: function getOwners() constant returns(address[]) func (_MultiSigWallet *MultiSigWalletCallerSession) GetOwners() ([]common.Address, error) { return _MultiSigWallet.Contract.GetOwners(&_MultiSigWallet.CallOpts) } // GetTransactionCount is a free data retrieval call binding the contract method 0x54741525. // // Solidity: function getTransactionCount(pending bool, executed bool) constant returns(count uint256) func (_MultiSigWallet *MultiSigWalletCaller) GetTransactionCount(opts *bind.CallOpts, pending bool, executed bool) (*big.Int, error) { var ( ret0 = new(*big.Int) ) out := &[]interface{}{ ret0, } err := _MultiSigWallet.contract.Call(opts, out, "getTransactionCount", pending, executed) return *ret0, err } // GetTransactionCount is a free data retrieval call binding the contract method 0x54741525. // // Solidity: function getTransactionCount(pending bool, executed bool) constant returns(count uint256) func (_MultiSigWallet *MultiSigWalletSession) GetTransactionCount(pending bool, executed bool) (*big.Int, error) { return _MultiSigWallet.Contract.GetTransactionCount(&_MultiSigWallet.CallOpts, pending, executed) } // GetTransactionCount is a free data retrieval call binding the contract method 0x54741525. // // Solidity: function getTransactionCount(pending bool, executed bool) constant returns(count uint256) func (_MultiSigWallet *MultiSigWalletCallerSession) GetTransactionCount(pending bool, executed bool) (*big.Int, error) { return _MultiSigWallet.Contract.GetTransactionCount(&_MultiSigWallet.CallOpts, pending, executed) } // GetTransactionIds is a free data retrieval call binding the contract method 0xa8abe69a. // // Solidity: function getTransactionIds(from uint256, to uint256, pending bool, executed bool) constant returns(_transactionIds uint256[]) func (_MultiSigWallet *MultiSigWalletCaller) GetTransactionIds(opts *bind.CallOpts, from *big.Int, to *big.Int, pending bool, executed bool) ([]*big.Int, error) { var ( ret0 = new([]*big.Int) ) out := &[]interface{}{ ret0, } err := _MultiSigWallet.contract.Call(opts, out, "getTransactionIds", from, to, pending, executed) return *ret0, err } // GetTransactionIds is a free data retrieval call binding the contract method 0xa8abe69a. // // Solidity: function getTransactionIds(from uint256, to uint256, pending bool, executed bool) constant returns(_transactionIds uint256[]) func (_MultiSigWallet *MultiSigWalletSession) GetTransactionIds(from *big.Int, to *big.Int, pending bool, executed bool) ([]*big.Int, error) { return _MultiSigWallet.Contract.GetTransactionIds(&_MultiSigWallet.CallOpts, from, to, pending, executed) } // GetTransactionIds is a free data retrieval call binding the contract method 0xa8abe69a. // // Solidity: function getTransactionIds(from uint256, to uint256, pending bool, executed bool) constant returns(_transactionIds uint256[]) func (_MultiSigWallet *MultiSigWalletCallerSession) GetTransactionIds(from *big.Int, to *big.Int, pending bool, executed bool) ([]*big.Int, error) { return _MultiSigWallet.Contract.GetTransactionIds(&_MultiSigWallet.CallOpts, from, to, pending, executed) } // IsConfirmed is a free data retrieval call binding the contract method 0x784547a7. // // Solidity: function isConfirmed(transactionId uint256) constant returns(bool) func (_MultiSigWallet *MultiSigWalletCaller) IsConfirmed(opts *bind.CallOpts, transactionId *big.Int) (bool, error) { var ( ret0 = new(bool) ) out := &[]interface{}{ ret0, } err := _MultiSigWallet.contract.Call(opts, out, "isConfirmed", transactionId) return *ret0, err } // IsConfirmed is a free data retrieval call binding the contract method 0x784547a7. // // Solidity: function isConfirmed(transactionId uint256) constant returns(bool) func (_MultiSigWallet *MultiSigWalletSession) IsConfirmed(transactionId *big.Int) (bool, error) { return _MultiSigWallet.Contract.IsConfirmed(&_MultiSigWallet.CallOpts, transactionId) } // IsConfirmed is a free data retrieval call binding the contract method 0x784547a7. // // Solidity: function isConfirmed(transactionId uint256) constant returns(bool) func (_MultiSigWallet *MultiSigWalletCallerSession) IsConfirmed(transactionId *big.Int) (bool, error) { return _MultiSigWallet.Contract.IsConfirmed(&_MultiSigWallet.CallOpts, transactionId) } // IsOwner is a free data retrieval call binding the contract method 0x2f54bf6e. // // Solidity: function isOwner( address) constant returns(bool) func (_MultiSigWallet *MultiSigWalletCaller) IsOwner(opts *bind.CallOpts, arg0 common.Address) (bool, error) { var ( ret0 = new(bool) ) out := &[]interface{}{ ret0, } err := _MultiSigWallet.contract.Call(opts, out, "isOwner", arg0) return *ret0, err } // IsOwner is a free data retrieval call binding the contract method 0x2f54bf6e. // // Solidity: function isOwner( address) constant returns(bool) func (_MultiSigWallet *MultiSigWalletSession) IsOwner(arg0 common.Address) (bool, error) { return _MultiSigWallet.Contract.IsOwner(&_MultiSigWallet.CallOpts, arg0) } // IsOwner is a free data retrieval call binding the contract method 0x2f54bf6e. // // Solidity: function isOwner( address) constant returns(bool) func (_MultiSigWallet *MultiSigWalletCallerSession) IsOwner(arg0 common.Address) (bool, error) { return _MultiSigWallet.Contract.IsOwner(&_MultiSigWallet.CallOpts, arg0) } // Owners is a free data retrieval call binding the contract method 0x025e7c27. // // Solidity: function owners( uint256) constant returns(address) func (_MultiSigWallet *MultiSigWalletCaller) Owners(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error) { var ( ret0 = new(common.Address) ) out := &[]interface{}{ ret0, } err := _MultiSigWallet.contract.Call(opts, out, "owners", arg0) return *ret0, err } // Owners is a free data retrieval call binding the contract method 0x025e7c27. // // Solidity: function owners( uint256) constant returns(address) func (_MultiSigWallet *MultiSigWalletSession) Owners(arg0 *big.Int) (common.Address, error) { return _MultiSigWallet.Contract.Owners(&_MultiSigWallet.CallOpts, arg0) } // Owners is a free data retrieval call binding the contract method 0x025e7c27. // // Solidity: function owners( uint256) constant returns(address) func (_MultiSigWallet *MultiSigWalletCallerSession) Owners(arg0 *big.Int) (common.Address, error) { return _MultiSigWallet.Contract.Owners(&_MultiSigWallet.CallOpts, arg0) } // Required is a free data retrieval call binding the contract method 0xdc8452cd. // // Solidity: function required() constant returns(uint256) func (_MultiSigWallet *MultiSigWalletCaller) Required(opts *bind.CallOpts) (*big.Int, error) { var ( ret0 = new(*big.Int) ) out := &[]interface{}{ ret0, } err := _MultiSigWallet.contract.Call(opts, out, "required") return *ret0, err } // Required is a free data retrieval call binding the contract method 0xdc8452cd. // // Solidity: function required() constant returns(uint256) func (_MultiSigWallet *MultiSigWalletSession) Required() (*big.Int, error) { return _MultiSigWallet.Contract.Required(&_MultiSigWallet.CallOpts) } // Required is a free data retrieval call binding the contract method 0xdc8452cd. // // Solidity: function required() constant returns(uint256) func (_MultiSigWallet *MultiSigWalletCallerSession) Required() (*big.Int, error) { return _MultiSigWallet.Contract.Required(&_MultiSigWallet.CallOpts) } // TransactionCount is a free data retrieval call binding the contract method 0xb77bf600. // // Solidity: function transactionCount() constant returns(uint256) func (_MultiSigWallet *MultiSigWalletCaller) TransactionCount(opts *bind.CallOpts) (*big.Int, error) { var ( ret0 = new(*big.Int) ) out := &[]interface{}{ ret0, } err := _MultiSigWallet.contract.Call(opts, out, "transactionCount") return *ret0, err } // TransactionCount is a free data retrieval call binding the contract method 0xb77bf600. // // Solidity: function transactionCount() constant returns(uint256) func (_MultiSigWallet *MultiSigWalletSession) TransactionCount() (*big.Int, error) { return _MultiSigWallet.Contract.TransactionCount(&_MultiSigWallet.CallOpts) } // TransactionCount is a free data retrieval call binding the contract method 0xb77bf600. // // Solidity: function transactionCount() constant returns(uint256) func (_MultiSigWallet *MultiSigWalletCallerSession) TransactionCount() (*big.Int, error) { return _MultiSigWallet.Contract.TransactionCount(&_MultiSigWallet.CallOpts) } // Transactions is a free data retrieval call binding the contract method 0x9ace38c2. // // Solidity: function transactions( uint256) constant returns(destination address, value uint256, data bytes, executed bool) func (_MultiSigWallet *MultiSigWalletCaller) Transactions(opts *bind.CallOpts, arg0 *big.Int) (struct { Destination common.Address Value *big.Int Data []byte Executed bool }, error) { ret := new(struct { Destination common.Address Value *big.Int Data []byte Executed bool }) out := &[]interface{}{ ret, } err := _MultiSigWallet.contract.Call(opts, out, "transactions", arg0) return *ret, err } // Transactions is a free data retrieval call binding the contract method 0x9ace38c2. // // Solidity: function transactions( uint256) constant returns(destination address, value uint256, data bytes, executed bool) func (_MultiSigWallet *MultiSigWalletSession) Transactions(arg0 *big.Int) (struct { Destination common.Address Value *big.Int Data []byte Executed bool }, error) { return _MultiSigWallet.Contract.Transactions(&_MultiSigWallet.CallOpts, arg0) } // Transactions is a free data retrieval call binding the contract method 0x9ace38c2. // // Solidity: function transactions( uint256) constant returns(destination address, value uint256, data bytes, executed bool) func (_MultiSigWallet *MultiSigWalletCallerSession) Transactions(arg0 *big.Int) (struct { Destination common.Address Value *big.Int Data []byte Executed bool }, error) { return _MultiSigWallet.Contract.Transactions(&_MultiSigWallet.CallOpts, arg0) } // AddOwner is a paid mutator transaction binding the contract method 0x7065cb48. // // Solidity: function addOwner(owner address) returns() func (_MultiSigWallet *MultiSigWalletTransactor) AddOwner(opts *bind.TransactOpts, owner common.Address) (*types.Transaction, error) { return _MultiSigWallet.contract.Transact(opts, "addOwner", owner) } // AddOwner is a paid mutator transaction binding the contract method 0x7065cb48. // // Solidity: function addOwner(owner address) returns() func (_MultiSigWallet *MultiSigWalletSession) AddOwner(owner common.Address) (*types.Transaction, error) { return _MultiSigWallet.Contract.AddOwner(&_MultiSigWallet.TransactOpts, owner) } // AddOwner is a paid mutator transaction binding the contract method 0x7065cb48. // // Solidity: function addOwner(owner address) returns() func (_MultiSigWallet *MultiSigWalletTransactorSession) AddOwner(owner common.Address) (*types.Transaction, error) { return _MultiSigWallet.Contract.AddOwner(&_MultiSigWallet.TransactOpts, owner) } // ChangeRequirement is a paid mutator transaction binding the contract method 0xba51a6df. // // Solidity: function changeRequirement(_required uint256) returns() func (_MultiSigWallet *MultiSigWalletTransactor) ChangeRequirement(opts *bind.TransactOpts, _required *big.Int) (*types.Transaction, error) { return _MultiSigWallet.contract.Transact(opts, "changeRequirement", _required) } // ChangeRequirement is a paid mutator transaction binding the contract method 0xba51a6df. // // Solidity: function changeRequirement(_required uint256) returns() func (_MultiSigWallet *MultiSigWalletSession) ChangeRequirement(_required *big.Int) (*types.Transaction, error) { return _MultiSigWallet.Contract.ChangeRequirement(&_MultiSigWallet.TransactOpts, _required) } // ChangeRequirement is a paid mutator transaction binding the contract method 0xba51a6df. // // Solidity: function changeRequirement(_required uint256) returns() func (_MultiSigWallet *MultiSigWalletTransactorSession) ChangeRequirement(_required *big.Int) (*types.Transaction, error) { return _MultiSigWallet.Contract.ChangeRequirement(&_MultiSigWallet.TransactOpts, _required) } // ConfirmTransaction is a paid mutator transaction binding the contract method 0xc01a8c84. // // Solidity: function confirmTransaction(transactionId uint256) returns() func (_MultiSigWallet *MultiSigWalletTransactor) ConfirmTransaction(opts *bind.TransactOpts, transactionId *big.Int) (*types.Transaction, error) { return _MultiSigWallet.contract.Transact(opts, "confirmTransaction", transactionId) } // ConfirmTransaction is a paid mutator transaction binding the contract method 0xc01a8c84. // // Solidity: function confirmTransaction(transactionId uint256) returns() func (_MultiSigWallet *MultiSigWalletSession) ConfirmTransaction(transactionId *big.Int) (*types.Transaction, error) { return _MultiSigWallet.Contract.ConfirmTransaction(&_MultiSigWallet.TransactOpts, transactionId) } // ConfirmTransaction is a paid mutator transaction binding the contract method 0xc01a8c84. // // Solidity: function confirmTransaction(transactionId uint256) returns() func (_MultiSigWallet *MultiSigWalletTransactorSession) ConfirmTransaction(transactionId *big.Int) (*types.Transaction, error) { return _MultiSigWallet.Contract.ConfirmTransaction(&_MultiSigWallet.TransactOpts, transactionId) } // ExecuteTransaction is a paid mutator transaction binding the contract method 0xee22610b. // // Solidity: function executeTransaction(transactionId uint256) returns() func (_MultiSigWallet *MultiSigWalletTransactor) ExecuteTransaction(opts *bind.TransactOpts, transactionId *big.Int) (*types.Transaction, error) { return _MultiSigWallet.contract.Transact(opts, "executeTransaction", transactionId) } // ExecuteTransaction is a paid mutator transaction binding the contract method 0xee22610b. // // Solidity: function executeTransaction(transactionId uint256) returns() func (_MultiSigWallet *MultiSigWalletSession) ExecuteTransaction(transactionId *big.Int) (*types.Transaction, error) { return _MultiSigWallet.Contract.ExecuteTransaction(&_MultiSigWallet.TransactOpts, transactionId) } // ExecuteTransaction is a paid mutator transaction binding the contract method 0xee22610b. // // Solidity: function executeTransaction(transactionId uint256) returns() func (_MultiSigWallet *MultiSigWalletTransactorSession) ExecuteTransaction(transactionId *big.Int) (*types.Transaction, error) { return _MultiSigWallet.Contract.ExecuteTransaction(&_MultiSigWallet.TransactOpts, transactionId) } // RemoveOwner is a paid mutator transaction binding the contract method 0x173825d9. // // Solidity: function removeOwner(owner address) returns() func (_MultiSigWallet *MultiSigWalletTransactor) RemoveOwner(opts *bind.TransactOpts, owner common.Address) (*types.Transaction, error) { return _MultiSigWallet.contract.Transact(opts, "removeOwner", owner) } // RemoveOwner is a paid mutator transaction binding the contract method 0x173825d9. // // Solidity: function removeOwner(owner address) returns() func (_MultiSigWallet *MultiSigWalletSession) RemoveOwner(owner common.Address) (*types.Transaction, error) { return _MultiSigWallet.Contract.RemoveOwner(&_MultiSigWallet.TransactOpts, owner) } // RemoveOwner is a paid mutator transaction binding the contract method 0x173825d9. // // Solidity: function removeOwner(owner address) returns() func (_MultiSigWallet *MultiSigWalletTransactorSession) RemoveOwner(owner common.Address) (*types.Transaction, error) { return _MultiSigWallet.Contract.RemoveOwner(&_MultiSigWallet.TransactOpts, owner) } // ReplaceOwner is a paid mutator transaction binding the contract method 0xe20056e6. // // Solidity: function replaceOwner(owner address, newOwner address) returns() func (_MultiSigWallet *MultiSigWalletTransactor) ReplaceOwner(opts *bind.TransactOpts, owner common.Address, newOwner common.Address) (*types.Transaction, error) { return _MultiSigWallet.contract.Transact(opts, "replaceOwner", owner, newOwner) } // ReplaceOwner is a paid mutator transaction binding the contract method 0xe20056e6. // // Solidity: function replaceOwner(owner address, newOwner address) returns() func (_MultiSigWallet *MultiSigWalletSession) ReplaceOwner(owner common.Address, newOwner common.Address) (*types.Transaction, error) { return _MultiSigWallet.Contract.ReplaceOwner(&_MultiSigWallet.TransactOpts, owner, newOwner) } // ReplaceOwner is a paid mutator transaction binding the contract method 0xe20056e6. // // Solidity: function replaceOwner(owner address, newOwner address) returns() func (_MultiSigWallet *MultiSigWalletTransactorSession) ReplaceOwner(owner common.Address, newOwner common.Address) (*types.Transaction, error) { return _MultiSigWallet.Contract.ReplaceOwner(&_MultiSigWallet.TransactOpts, owner, newOwner) } // RevokeConfirmation is a paid mutator transaction binding the contract method 0x20ea8d86. // // Solidity: function revokeConfirmation(transactionId uint256) returns() func (_MultiSigWallet *MultiSigWalletTransactor) RevokeConfirmation(opts *bind.TransactOpts, transactionId *big.Int) (*types.Transaction, error) { return _MultiSigWallet.contract.Transact(opts, "revokeConfirmation", transactionId) } // RevokeConfirmation is a paid mutator transaction binding the contract method 0x20ea8d86. // // Solidity: function revokeConfirmation(transactionId uint256) returns() func (_MultiSigWallet *MultiSigWalletSession) RevokeConfirmation(transactionId *big.Int) (*types.Transaction, error) { return _MultiSigWallet.Contract.RevokeConfirmation(&_MultiSigWallet.TransactOpts, transactionId) } // RevokeConfirmation is a paid mutator transaction binding the contract method 0x20ea8d86. // // Solidity: function revokeConfirmation(transactionId uint256) returns() func (_MultiSigWallet *MultiSigWalletTransactorSession) RevokeConfirmation(transactionId *big.Int) (*types.Transaction, error) { return _MultiSigWallet.Contract.RevokeConfirmation(&_MultiSigWallet.TransactOpts, transactionId) } // SubmitTransaction is a paid mutator transaction binding the contract method 0xc6427474. // // Solidity: function submitTransaction(destination address, value uint256, data bytes) returns(transactionId uint256) func (_MultiSigWallet *MultiSigWalletTransactor) SubmitTransaction(opts *bind.TransactOpts, destination common.Address, value *big.Int, data []byte) (*types.Transaction, error) { return _MultiSigWallet.contract.Transact(opts, "submitTransaction", destination, value, data) } // SubmitTransaction is a paid mutator transaction binding the contract method 0xc6427474. // // Solidity: function submitTransaction(destination address, value uint256, data bytes) returns(transactionId uint256) func (_MultiSigWallet *MultiSigWalletSession) SubmitTransaction(destination common.Address, value *big.Int, data []byte) (*types.Transaction, error) { return _MultiSigWallet.Contract.SubmitTransaction(&_MultiSigWallet.TransactOpts, destination, value, data) } // SubmitTransaction is a paid mutator transaction binding the contract method 0xc6427474. // // Solidity: function submitTransaction(destination address, value uint256, data bytes) returns(transactionId uint256) func (_MultiSigWallet *MultiSigWalletTransactorSession) SubmitTransaction(destination common.Address, value *big.Int, data []byte) (*types.Transaction, error) { return _MultiSigWallet.Contract.SubmitTransaction(&_MultiSigWallet.TransactOpts, destination, value, data) } // 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. type MultiSigWalletConfirmationIterator struct { Event *MultiSigWalletConfirmation // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data logs chan types.Log // Log channel receiving the found contract events sub ethereum.Subscription // Subscription for errors, completion and termination done bool // Whether the subscription completed delivering logs fail error // Occurred error to stop iteration } // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. func (it *MultiSigWalletConfirmationIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false } // If the iterator completed, deliver directly whatever's available if it.done { select { case log := <-it.logs: it.Event = new(MultiSigWalletConfirmation) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false } it.Event.Raw = log return true default: return false } } // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: it.Event = new(MultiSigWalletConfirmation) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false } it.Event.Raw = log return true case err := <-it.sub.Err(): it.done = true it.fail = err return it.Next() } } // Error returns any retrieval or parsing error occurred during filtering. func (it *MultiSigWalletConfirmationIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. func (it *MultiSigWalletConfirmationIterator) Close() error { it.sub.Unsubscribe() return nil } // MultiSigWalletConfirmation represents a Confirmation event raised by the MultiSigWallet contract. type MultiSigWalletConfirmation struct { Sender common.Address TransactionId *big.Int Raw types.Log // Blockchain specific contextual infos } // FilterConfirmation is a free log retrieval operation binding the contract event 0x4a504a94899432a9846e1aa406dceb1bcfd538bb839071d49d1e5e23f5be30ef. // // Solidity: event Confirmation(sender indexed address, transactionId indexed uint256) func (_MultiSigWallet *MultiSigWalletFilterer) FilterConfirmation(opts *bind.FilterOpts, sender []common.Address, transactionId []*big.Int) (*MultiSigWalletConfirmationIterator, error) { var senderRule []interface{} for _, senderItem := range sender { senderRule = append(senderRule, senderItem) } var transactionIdRule []interface{} for _, transactionIdItem := range transactionId { transactionIdRule = append(transactionIdRule, transactionIdItem) } logs, sub, err := _MultiSigWallet.contract.FilterLogs(opts, "Confirmation", senderRule, transactionIdRule) if err != nil { return nil, err } return &MultiSigWalletConfirmationIterator{contract: _MultiSigWallet.contract, event: "Confirmation", logs: logs, sub: sub}, nil } // WatchConfirmation is a free log subscription operation binding the contract event 0x4a504a94899432a9846e1aa406dceb1bcfd538bb839071d49d1e5e23f5be30ef. // // Solidity: event Confirmation(sender indexed address, transactionId indexed uint256) func (_MultiSigWallet *MultiSigWalletFilterer) WatchConfirmation(opts *bind.WatchOpts, sink chan<- *MultiSigWalletConfirmation, sender []common.Address, transactionId []*big.Int) (event.Subscription, error) { var senderRule []interface{} for _, senderItem := range sender { senderRule = append(senderRule, senderItem) } var transactionIdRule []interface{} for _, transactionIdItem := range transactionId { transactionIdRule = append(transactionIdRule, transactionIdItem) } logs, sub, err := _MultiSigWallet.contract.WatchLogs(opts, "Confirmation", senderRule, transactionIdRule) if err != nil { return nil, err } return event.NewSubscription(func(quit <-chan struct{}) error { defer sub.Unsubscribe() for { select { case log := <-logs: // New log arrived, parse the event and forward to the user event := new(MultiSigWalletConfirmation) if err := _MultiSigWallet.contract.UnpackLog(event, "Confirmation", log); err != nil { return err } event.Raw = log select { case sink <- event: case err := <-sub.Err(): return err case <-quit: return nil } case err := <-sub.Err(): return err case <-quit: return nil } } }), nil } // 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. type MultiSigWalletDepositIterator struct { Event *MultiSigWalletDeposit // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data logs chan types.Log // Log channel receiving the found contract events sub ethereum.Subscription // Subscription for errors, completion and termination done bool // Whether the subscription completed delivering logs fail error // Occurred error to stop iteration } // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. func (it *MultiSigWalletDepositIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false } // If the iterator completed, deliver directly whatever's available if it.done { select { case log := <-it.logs: it.Event = new(MultiSigWalletDeposit) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false } it.Event.Raw = log return true default: return false } } // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: it.Event = new(MultiSigWalletDeposit) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false } it.Event.Raw = log return true case err := <-it.sub.Err(): it.done = true it.fail = err return it.Next() } } // Error returns any retrieval or parsing error occurred during filtering. func (it *MultiSigWalletDepositIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. func (it *MultiSigWalletDepositIterator) Close() error { it.sub.Unsubscribe() return nil } // MultiSigWalletDeposit represents a Deposit event raised by the MultiSigWallet contract. type MultiSigWalletDeposit struct { Sender common.Address Value *big.Int Raw types.Log // Blockchain specific contextual infos } // FilterDeposit is a free log retrieval operation binding the contract event 0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c. // // Solidity: event Deposit(sender indexed address, value uint256) func (_MultiSigWallet *MultiSigWalletFilterer) FilterDeposit(opts *bind.FilterOpts, sender []common.Address) (*MultiSigWalletDepositIterator, error) { var senderRule []interface{} for _, senderItem := range sender { senderRule = append(senderRule, senderItem) } logs, sub, err := _MultiSigWallet.contract.FilterLogs(opts, "Deposit", senderRule) if err != nil { return nil, err } return &MultiSigWalletDepositIterator{contract: _MultiSigWallet.contract, event: "Deposit", logs: logs, sub: sub}, nil } // WatchDeposit is a free log subscription operation binding the contract event 0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c. // // Solidity: event Deposit(sender indexed address, value uint256) func (_MultiSigWallet *MultiSigWalletFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *MultiSigWalletDeposit, sender []common.Address) (event.Subscription, error) { var senderRule []interface{} for _, senderItem := range sender { senderRule = append(senderRule, senderItem) } logs, sub, err := _MultiSigWallet.contract.WatchLogs(opts, "Deposit", senderRule) if err != nil { return nil, err } return event.NewSubscription(func(quit <-chan struct{}) error { defer sub.Unsubscribe() for { select { case log := <-logs: // New log arrived, parse the event and forward to the user event := new(MultiSigWalletDeposit) if err := _MultiSigWallet.contract.UnpackLog(event, "Deposit", log); err != nil { return err } event.Raw = log select { case sink <- event: case err := <-sub.Err(): return err case <-quit: return nil } case err := <-sub.Err(): return err case <-quit: return nil } } }), nil } // 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. type MultiSigWalletExecutionIterator struct { Event *MultiSigWalletExecution // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data logs chan types.Log // Log channel receiving the found contract events sub ethereum.Subscription // Subscription for errors, completion and termination done bool // Whether the subscription completed delivering logs fail error // Occurred error to stop iteration } // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. func (it *MultiSigWalletExecutionIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false } // If the iterator completed, deliver directly whatever's available if it.done { select { case log := <-it.logs: it.Event = new(MultiSigWalletExecution) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false } it.Event.Raw = log return true default: return false } } // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: it.Event = new(MultiSigWalletExecution) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false } it.Event.Raw = log return true case err := <-it.sub.Err(): it.done = true it.fail = err return it.Next() } } // Error returns any retrieval or parsing error occurred during filtering. func (it *MultiSigWalletExecutionIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. func (it *MultiSigWalletExecutionIterator) Close() error { it.sub.Unsubscribe() return nil } // MultiSigWalletExecution represents a Execution event raised by the MultiSigWallet contract. type MultiSigWalletExecution struct { TransactionId *big.Int Raw types.Log // Blockchain specific contextual infos } // FilterExecution is a free log retrieval operation binding the contract event 0x33e13ecb54c3076d8e8bb8c2881800a4d972b792045ffae98fdf46df365fed75. // // Solidity: event Execution(transactionId indexed uint256) func (_MultiSigWallet *MultiSigWalletFilterer) FilterExecution(opts *bind.FilterOpts, transactionId []*big.Int) (*MultiSigWalletExecutionIterator, error) { var transactionIdRule []interface{} for _, transactionIdItem := range transactionId { transactionIdRule = append(transactionIdRule, transactionIdItem) } logs, sub, err := _MultiSigWallet.contract.FilterLogs(opts, "Execution", transactionIdRule) if err != nil { return nil, err } return &MultiSigWalletExecutionIterator{contract: _MultiSigWallet.contract, event: "Execution", logs: logs, sub: sub}, nil } // WatchExecution is a free log subscription operation binding the contract event 0x33e13ecb54c3076d8e8bb8c2881800a4d972b792045ffae98fdf46df365fed75. // // Solidity: event Execution(transactionId indexed uint256) func (_MultiSigWallet *MultiSigWalletFilterer) WatchExecution(opts *bind.WatchOpts, sink chan<- *MultiSigWalletExecution, transactionId []*big.Int) (event.Subscription, error) { var transactionIdRule []interface{} for _, transactionIdItem := range transactionId { transactionIdRule = append(transactionIdRule, transactionIdItem) } logs, sub, err := _MultiSigWallet.contract.WatchLogs(opts, "Execution", transactionIdRule) if err != nil { return nil, err } return event.NewSubscription(func(quit <-chan struct{}) error { defer sub.Unsubscribe() for { select { case log := <-logs: // New log arrived, parse the event and forward to the user event := new(MultiSigWalletExecution) if err := _MultiSigWallet.contract.UnpackLog(event, "Execution", log); err != nil { return err } event.Raw = log select { case sink <- event: case err := <-sub.Err(): return err case <-quit: return nil } case err := <-sub.Err(): return err case <-quit: return nil } } }), nil } // 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. type MultiSigWalletExecutionFailureIterator struct { Event *MultiSigWalletExecutionFailure // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data logs chan types.Log // Log channel receiving the found contract events sub ethereum.Subscription // Subscription for errors, completion and termination done bool // Whether the subscription completed delivering logs fail error // Occurred error to stop iteration } // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. func (it *MultiSigWalletExecutionFailureIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false } // If the iterator completed, deliver directly whatever's available if it.done { select { case log := <-it.logs: it.Event = new(MultiSigWalletExecutionFailure) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false } it.Event.Raw = log return true default: return false } } // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: it.Event = new(MultiSigWalletExecutionFailure) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false } it.Event.Raw = log return true case err := <-it.sub.Err(): it.done = true it.fail = err return it.Next() } } // Error returns any retrieval or parsing error occurred during filtering. func (it *MultiSigWalletExecutionFailureIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. func (it *MultiSigWalletExecutionFailureIterator) Close() error { it.sub.Unsubscribe() return nil } // MultiSigWalletExecutionFailure represents a ExecutionFailure event raised by the MultiSigWallet contract. type MultiSigWalletExecutionFailure struct { TransactionId *big.Int Raw types.Log // Blockchain specific contextual infos } // FilterExecutionFailure is a free log retrieval operation binding the contract event 0x526441bb6c1aba3c9a4a6ca1d6545da9c2333c8c48343ef398eb858d72b79236. // // Solidity: event ExecutionFailure(transactionId indexed uint256) func (_MultiSigWallet *MultiSigWalletFilterer) FilterExecutionFailure(opts *bind.FilterOpts, transactionId []*big.Int) (*MultiSigWalletExecutionFailureIterator, error) { var transactionIdRule []interface{} for _, transactionIdItem := range transactionId { transactionIdRule = append(transactionIdRule, transactionIdItem) } logs, sub, err := _MultiSigWallet.contract.FilterLogs(opts, "ExecutionFailure", transactionIdRule) if err != nil { return nil, err } return &MultiSigWalletExecutionFailureIterator{contract: _MultiSigWallet.contract, event: "ExecutionFailure", logs: logs, sub: sub}, nil } // WatchExecutionFailure is a free log subscription operation binding the contract event 0x526441bb6c1aba3c9a4a6ca1d6545da9c2333c8c48343ef398eb858d72b79236. // // Solidity: event ExecutionFailure(transactionId indexed uint256) func (_MultiSigWallet *MultiSigWalletFilterer) WatchExecutionFailure(opts *bind.WatchOpts, sink chan<- *MultiSigWalletExecutionFailure, transactionId []*big.Int) (event.Subscription, error) { var transactionIdRule []interface{} for _, transactionIdItem := range transactionId { transactionIdRule = append(transactionIdRule, transactionIdItem) } logs, sub, err := _MultiSigWallet.contract.WatchLogs(opts, "ExecutionFailure", transactionIdRule) if err != nil { return nil, err } return event.NewSubscription(func(quit <-chan struct{}) error { defer sub.Unsubscribe() for { select { case log := <-logs: // New log arrived, parse the event and forward to the user event := new(MultiSigWalletExecutionFailure) if err := _MultiSigWallet.contract.UnpackLog(event, "ExecutionFailure", log); err != nil { return err } event.Raw = log select { case sink <- event: case err := <-sub.Err(): return err case <-quit: return nil } case err := <-sub.Err(): return err case <-quit: return nil } } }), nil } // 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. type MultiSigWalletOwnerAdditionIterator struct { Event *MultiSigWalletOwnerAddition // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data logs chan types.Log // Log channel receiving the found contract events sub ethereum.Subscription // Subscription for errors, completion and termination done bool // Whether the subscription completed delivering logs fail error // Occurred error to stop iteration } // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. func (it *MultiSigWalletOwnerAdditionIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false } // If the iterator completed, deliver directly whatever's available if it.done { select { case log := <-it.logs: it.Event = new(MultiSigWalletOwnerAddition) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false } it.Event.Raw = log return true default: return false } } // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: it.Event = new(MultiSigWalletOwnerAddition) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false } it.Event.Raw = log return true case err := <-it.sub.Err(): it.done = true it.fail = err return it.Next() } } // Error returns any retrieval or parsing error occurred during filtering. func (it *MultiSigWalletOwnerAdditionIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. func (it *MultiSigWalletOwnerAdditionIterator) Close() error { it.sub.Unsubscribe() return nil } // MultiSigWalletOwnerAddition represents a OwnerAddition event raised by the MultiSigWallet contract. type MultiSigWalletOwnerAddition struct { Owner common.Address Raw types.Log // Blockchain specific contextual infos } // FilterOwnerAddition is a free log retrieval operation binding the contract event 0xf39e6e1eb0edcf53c221607b54b00cd28f3196fed0a24994dc308b8f611b682d. // // Solidity: event OwnerAddition(owner indexed address) func (_MultiSigWallet *MultiSigWalletFilterer) FilterOwnerAddition(opts *bind.FilterOpts, owner []common.Address) (*MultiSigWalletOwnerAdditionIterator, error) { var ownerRule []interface{} for _, ownerItem := range owner { ownerRule = append(ownerRule, ownerItem) } logs, sub, err := _MultiSigWallet.contract.FilterLogs(opts, "OwnerAddition", ownerRule) if err != nil { return nil, err } return &MultiSigWalletOwnerAdditionIterator{contract: _MultiSigWallet.contract, event: "OwnerAddition", logs: logs, sub: sub}, nil } // WatchOwnerAddition is a free log subscription operation binding the contract event 0xf39e6e1eb0edcf53c221607b54b00cd28f3196fed0a24994dc308b8f611b682d. // // Solidity: event OwnerAddition(owner indexed address) func (_MultiSigWallet *MultiSigWalletFilterer) WatchOwnerAddition(opts *bind.WatchOpts, sink chan<- *MultiSigWalletOwnerAddition, owner []common.Address) (event.Subscription, error) { var ownerRule []interface{} for _, ownerItem := range owner { ownerRule = append(ownerRule, ownerItem) } logs, sub, err := _MultiSigWallet.contract.WatchLogs(opts, "OwnerAddition", ownerRule) if err != nil { return nil, err } return event.NewSubscription(func(quit <-chan struct{}) error { defer sub.Unsubscribe() for { select { case log := <-logs: // New log arrived, parse the event and forward to the user event := new(MultiSigWalletOwnerAddition) if err := _MultiSigWallet.contract.UnpackLog(event, "OwnerAddition", log); err != nil { return err } event.Raw = log select { case sink <- event: case err := <-sub.Err(): return err case <-quit: return nil } case err := <-sub.Err(): return err case <-quit: return nil } } }), nil } // 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. type MultiSigWalletOwnerRemovalIterator struct { Event *MultiSigWalletOwnerRemoval // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data logs chan types.Log // Log channel receiving the found contract events sub ethereum.Subscription // Subscription for errors, completion and termination done bool // Whether the subscription completed delivering logs fail error // Occurred error to stop iteration } // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. func (it *MultiSigWalletOwnerRemovalIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false } // If the iterator completed, deliver directly whatever's available if it.done { select { case log := <-it.logs: it.Event = new(MultiSigWalletOwnerRemoval) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false } it.Event.Raw = log return true default: return false } } // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: it.Event = new(MultiSigWalletOwnerRemoval) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false } it.Event.Raw = log return true case err := <-it.sub.Err(): it.done = true it.fail = err return it.Next() } } // Error returns any retrieval or parsing error occurred during filtering. func (it *MultiSigWalletOwnerRemovalIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. func (it *MultiSigWalletOwnerRemovalIterator) Close() error { it.sub.Unsubscribe() return nil } // MultiSigWalletOwnerRemoval represents a OwnerRemoval event raised by the MultiSigWallet contract. type MultiSigWalletOwnerRemoval struct { Owner common.Address Raw types.Log // Blockchain specific contextual infos } // FilterOwnerRemoval is a free log retrieval operation binding the contract event 0x8001553a916ef2f495d26a907cc54d96ed840d7bda71e73194bf5a9df7a76b90. // // Solidity: event OwnerRemoval(owner indexed address) func (_MultiSigWallet *MultiSigWalletFilterer) FilterOwnerRemoval(opts *bind.FilterOpts, owner []common.Address) (*MultiSigWalletOwnerRemovalIterator, error) { var ownerRule []interface{} for _, ownerItem := range owner { ownerRule = append(ownerRule, ownerItem) } logs, sub, err := _MultiSigWallet.contract.FilterLogs(opts, "OwnerRemoval", ownerRule) if err != nil { return nil, err } return &MultiSigWalletOwnerRemovalIterator{contract: _MultiSigWallet.contract, event: "OwnerRemoval", logs: logs, sub: sub}, nil } // WatchOwnerRemoval is a free log subscription operation binding the contract event 0x8001553a916ef2f495d26a907cc54d96ed840d7bda71e73194bf5a9df7a76b90. // // Solidity: event OwnerRemoval(owner indexed address) func (_MultiSigWallet *MultiSigWalletFilterer) WatchOwnerRemoval(opts *bind.WatchOpts, sink chan<- *MultiSigWalletOwnerRemoval, owner []common.Address) (event.Subscription, error) { var ownerRule []interface{} for _, ownerItem := range owner { ownerRule = append(ownerRule, ownerItem) } logs, sub, err := _MultiSigWallet.contract.WatchLogs(opts, "OwnerRemoval", ownerRule) if err != nil { return nil, err } return event.NewSubscription(func(quit <-chan struct{}) error { defer sub.Unsubscribe() for { select { case log := <-logs: // New log arrived, parse the event and forward to the user event := new(MultiSigWalletOwnerRemoval) if err := _MultiSigWallet.contract.UnpackLog(event, "OwnerRemoval", log); err != nil { return err } event.Raw = log select { case sink <- event: case err := <-sub.Err(): return err case <-quit: return nil } case err := <-sub.Err(): return err case <-quit: return nil } } }), nil } // 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. type MultiSigWalletRequirementChangeIterator struct { Event *MultiSigWalletRequirementChange // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data logs chan types.Log // Log channel receiving the found contract events sub ethereum.Subscription // Subscription for errors, completion and termination done bool // Whether the subscription completed delivering logs fail error // Occurred error to stop iteration } // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. func (it *MultiSigWalletRequirementChangeIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false } // If the iterator completed, deliver directly whatever's available if it.done { select { case log := <-it.logs: it.Event = new(MultiSigWalletRequirementChange) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false } it.Event.Raw = log return true default: return false } } // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: it.Event = new(MultiSigWalletRequirementChange) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false } it.Event.Raw = log return true case err := <-it.sub.Err(): it.done = true it.fail = err return it.Next() } } // Error returns any retrieval or parsing error occurred during filtering. func (it *MultiSigWalletRequirementChangeIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. func (it *MultiSigWalletRequirementChangeIterator) Close() error { it.sub.Unsubscribe() return nil } // MultiSigWalletRequirementChange represents a RequirementChange event raised by the MultiSigWallet contract. type MultiSigWalletRequirementChange struct { Required *big.Int Raw types.Log // Blockchain specific contextual infos } // FilterRequirementChange is a free log retrieval operation binding the contract event 0xa3f1ee9126a074d9326c682f561767f710e927faa811f7a99829d49dc421797a. // // Solidity: event RequirementChange(required uint256) func (_MultiSigWallet *MultiSigWalletFilterer) FilterRequirementChange(opts *bind.FilterOpts) (*MultiSigWalletRequirementChangeIterator, error) { logs, sub, err := _MultiSigWallet.contract.FilterLogs(opts, "RequirementChange") if err != nil { return nil, err } return &MultiSigWalletRequirementChangeIterator{contract: _MultiSigWallet.contract, event: "RequirementChange", logs: logs, sub: sub}, nil } // WatchRequirementChange is a free log subscription operation binding the contract event 0xa3f1ee9126a074d9326c682f561767f710e927faa811f7a99829d49dc421797a. // // Solidity: event RequirementChange(required uint256) func (_MultiSigWallet *MultiSigWalletFilterer) WatchRequirementChange(opts *bind.WatchOpts, sink chan<- *MultiSigWalletRequirementChange) (event.Subscription, error) { logs, sub, err := _MultiSigWallet.contract.WatchLogs(opts, "RequirementChange") if err != nil { return nil, err } return event.NewSubscription(func(quit <-chan struct{}) error { defer sub.Unsubscribe() for { select { case log := <-logs: // New log arrived, parse the event and forward to the user event := new(MultiSigWalletRequirementChange) if err := _MultiSigWallet.contract.UnpackLog(event, "RequirementChange", log); err != nil { return err } event.Raw = log select { case sink <- event: case err := <-sub.Err(): return err case <-quit: return nil } case err := <-sub.Err(): return err case <-quit: return nil } } }), nil } // 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. type MultiSigWalletRevocationIterator struct { Event *MultiSigWalletRevocation // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data logs chan types.Log // Log channel receiving the found contract events sub ethereum.Subscription // Subscription for errors, completion and termination done bool // Whether the subscription completed delivering logs fail error // Occurred error to stop iteration } // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. func (it *MultiSigWalletRevocationIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false } // If the iterator completed, deliver directly whatever's available if it.done { select { case log := <-it.logs: it.Event = new(MultiSigWalletRevocation) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false } it.Event.Raw = log return true default: return false } } // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: it.Event = new(MultiSigWalletRevocation) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false } it.Event.Raw = log return true case err := <-it.sub.Err(): it.done = true it.fail = err return it.Next() } } // Error returns any retrieval or parsing error occurred during filtering. func (it *MultiSigWalletRevocationIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. func (it *MultiSigWalletRevocationIterator) Close() error { it.sub.Unsubscribe() return nil } // MultiSigWalletRevocation represents a Revocation event raised by the MultiSigWallet contract. type MultiSigWalletRevocation struct { Sender common.Address TransactionId *big.Int Raw types.Log // Blockchain specific contextual infos } // FilterRevocation is a free log retrieval operation binding the contract event 0xf6a317157440607f36269043eb55f1287a5a19ba2216afeab88cd46cbcfb88e9. // // Solidity: event Revocation(sender indexed address, transactionId indexed uint256) func (_MultiSigWallet *MultiSigWalletFilterer) FilterRevocation(opts *bind.FilterOpts, sender []common.Address, transactionId []*big.Int) (*MultiSigWalletRevocationIterator, error) { var senderRule []interface{} for _, senderItem := range sender { senderRule = append(senderRule, senderItem) } var transactionIdRule []interface{} for _, transactionIdItem := range transactionId { transactionIdRule = append(transactionIdRule, transactionIdItem) } logs, sub, err := _MultiSigWallet.contract.FilterLogs(opts, "Revocation", senderRule, transactionIdRule) if err != nil { return nil, err } return &MultiSigWalletRevocationIterator{contract: _MultiSigWallet.contract, event: "Revocation", logs: logs, sub: sub}, nil } // WatchRevocation is a free log subscription operation binding the contract event 0xf6a317157440607f36269043eb55f1287a5a19ba2216afeab88cd46cbcfb88e9. // // Solidity: event Revocation(sender indexed address, transactionId indexed uint256) func (_MultiSigWallet *MultiSigWalletFilterer) WatchRevocation(opts *bind.WatchOpts, sink chan<- *MultiSigWalletRevocation, sender []common.Address, transactionId []*big.Int) (event.Subscription, error) { var senderRule []interface{} for _, senderItem := range sender { senderRule = append(senderRule, senderItem) } var transactionIdRule []interface{} for _, transactionIdItem := range transactionId { transactionIdRule = append(transactionIdRule, transactionIdItem) } logs, sub, err := _MultiSigWallet.contract.WatchLogs(opts, "Revocation", senderRule, transactionIdRule) if err != nil { return nil, err } return event.NewSubscription(func(quit <-chan struct{}) error { defer sub.Unsubscribe() for { select { case log := <-logs: // New log arrived, parse the event and forward to the user event := new(MultiSigWalletRevocation) if err := _MultiSigWallet.contract.UnpackLog(event, "Revocation", log); err != nil { return err } event.Raw = log select { case sink <- event: case err := <-sub.Err(): return err case <-quit: return nil } case err := <-sub.Err(): return err case <-quit: return nil } } }), nil } // 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. type MultiSigWalletSubmissionIterator struct { Event *MultiSigWalletSubmission // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data logs chan types.Log // Log channel receiving the found contract events sub ethereum.Subscription // Subscription for errors, completion and termination done bool // Whether the subscription completed delivering logs fail error // Occurred error to stop iteration } // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. func (it *MultiSigWalletSubmissionIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false } // If the iterator completed, deliver directly whatever's available if it.done { select { case log := <-it.logs: it.Event = new(MultiSigWalletSubmission) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false } it.Event.Raw = log return true default: return false } } // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: it.Event = new(MultiSigWalletSubmission) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false } it.Event.Raw = log return true case err := <-it.sub.Err(): it.done = true it.fail = err return it.Next() } } // Error returns any retrieval or parsing error occurred during filtering. func (it *MultiSigWalletSubmissionIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. func (it *MultiSigWalletSubmissionIterator) Close() error { it.sub.Unsubscribe() return nil } // MultiSigWalletSubmission represents a Submission event raised by the MultiSigWallet contract. type MultiSigWalletSubmission struct { TransactionId *big.Int Raw types.Log // Blockchain specific contextual infos } // FilterSubmission is a free log retrieval operation binding the contract event 0xc0ba8fe4b176c1714197d43b9cc6bcf797a4a7461c5fe8d0ef6e184ae7601e51. // // Solidity: event Submission(transactionId indexed uint256) func (_MultiSigWallet *MultiSigWalletFilterer) FilterSubmission(opts *bind.FilterOpts, transactionId []*big.Int) (*MultiSigWalletSubmissionIterator, error) { var transactionIdRule []interface{} for _, transactionIdItem := range transactionId { transactionIdRule = append(transactionIdRule, transactionIdItem) } logs, sub, err := _MultiSigWallet.contract.FilterLogs(opts, "Submission", transactionIdRule) if err != nil { return nil, err } return &MultiSigWalletSubmissionIterator{contract: _MultiSigWallet.contract, event: "Submission", logs: logs, sub: sub}, nil } // WatchSubmission is a free log subscription operation binding the contract event 0xc0ba8fe4b176c1714197d43b9cc6bcf797a4a7461c5fe8d0ef6e184ae7601e51. // // Solidity: event Submission(transactionId indexed uint256) func (_MultiSigWallet *MultiSigWalletFilterer) WatchSubmission(opts *bind.WatchOpts, sink chan<- *MultiSigWalletSubmission, transactionId []*big.Int) (event.Subscription, error) { var transactionIdRule []interface{} for _, transactionIdItem := range transactionId { transactionIdRule = append(transactionIdRule, transactionIdItem) } logs, sub, err := _MultiSigWallet.contract.WatchLogs(opts, "Submission", transactionIdRule) if err != nil { return nil, err } return event.NewSubscription(func(quit <-chan struct{}) error { defer sub.Unsubscribe() for { select { case log := <-logs: // New log arrived, parse the event and forward to the user event := new(MultiSigWalletSubmission) if err := _MultiSigWallet.contract.UnpackLog(event, "Submission", log); err != nil { return err } event.Raw = log select { case sink <- event: case err := <-sub.Err(): return err case <-quit: return nil } case err := <-sub.Err(): return err case <-quit: return nil } } }), nil }