generated

package
v1.66.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 30, 2021 License: BSD-3-Clause Imports: 8 Imported by: 2

Documentation

Index

Constants

View Source 
const EnumABI = "[]"

EnumABI is the input ABI used to generate the binding from.

View Source 
const EtherPaymentFallbackABI = "[{\"stateMutability\":\"payable\",\"type\":\"receive\"}]"

EtherPaymentFallbackABI is the input ABI used to generate the binding from.

View Source 
const ExecutorABI = "[]"

ExecutorABI is the input ABI used to generate the binding from.

View Source 
const FallbackManagerABI = "" /* 252-byte string literal not displayed */

FallbackManagerABI is the input ABI used to generate the binding from.

View Source 
const GnosisSafeABI = "" /* 14449-byte string literal not displayed */

GnosisSafeABI is the input ABI used to generate the binding from.

View Source 
const GnosisSafeMathABI = "[]"

GnosisSafeMathABI is the input ABI used to generate the binding from.

View Source 
const ISignatureValidatorABI = "" /* 314-byte string literal not displayed */

ISignatureValidatorABI is the input ABI used to generate the binding from.

View Source 
const ISignatureValidatorConstantsABI = "[]"

ISignatureValidatorConstantsABI is the input ABI used to generate the binding from.

View Source 
const ModuleManagerABI = "" /* 2845-byte string literal not displayed */

ModuleManagerABI is the input ABI used to generate the binding from.

View Source 
const OwnerManagerABI = "" /* 2221-byte string literal not displayed */

OwnerManagerABI is the input ABI used to generate the binding from.

View Source 
const SecuredTokenTransferABI = "[]"

SecuredTokenTransferABI is the input ABI used to generate the binding from.

View Source 
const SelfAuthorizedABI = "[]"

SelfAuthorizedABI is the input ABI used to generate the binding from.

View Source 
const SignatureDecoderABI = "[]"

SignatureDecoderABI is the input ABI used to generate the binding from.

View Source 
const SingletonABI = "[]"

SingletonABI is the input ABI used to generate the binding from.

View Source 
const StorageAccessibleABI = "" /* 999-byte string literal not displayed */

StorageAccessibleABI is the input ABI used to generate the binding from.

Variables

View Source 
var EnumBin = "" /* 186-byte string literal not displayed */

EnumBin is the compiled bytecode used for deploying new contracts.

View Source 
var EtherPaymentFallbackBin = "" /* 198-byte string literal not displayed */

EtherPaymentFallbackBin is the compiled bytecode used for deploying new contracts.

View Source 
var ExecutorBin = "" /* 186-byte string literal not displayed */

ExecutorBin is the compiled bytecode used for deploying new contracts.

View Source 
var FallbackManagerBin = "" /* 846-byte string literal not displayed */

FallbackManagerBin is the compiled bytecode used for deploying new contracts.

View Source 
var FallbackManagerFuncSigs = map[string]string{
	"f08a0323": "setFallbackHandler(address)",
}

FallbackManagerFuncSigs maps the 4-byte function signature to its string representation.

View Source 
var GnosisSafeBin = "" /* 30292-byte string literal not displayed */

GnosisSafeBin is the compiled bytecode used for deploying new contracts.

View Source 
var GnosisSafeFuncSigs = map[string]string{
	"a3f4df7e": "NAME()",
	"ffa1ad74": "VERSION()",
	"0d582f13": "addOwnerWithThreshold(address,uint256)",
	"d4d9bdcd": "approveHash(bytes32)",
	"7d832974": "approvedHashes(address,bytes32)",
	"694e80c3": "changeThreshold(uint256)",
	"934f3a11": "checkSignatures(bytes32,bytes,bytes)",
	"e009cfde": "disableModule(address,address)",
	"f698da25": "domainSeparator()",
	"610b5925": "enableModule(address)",
	"e86637db": "encodeTransactionData(address,uint256,bytes,uint8,uint256,uint256,uint256,address,address,uint256)",
	"6a761202": "execTransaction(address,uint256,bytes,uint8,uint256,uint256,uint256,address,address,bytes)",
	"468721a7": "execTransactionFromModule(address,uint256,bytes,uint8)",
	"5229073f": "execTransactionFromModuleReturnData(address,uint256,bytes,uint8)",
	"3408e470": "getChainId()",
	"0a1028c4": "getMessageHash(bytes)",
	"cc2f8452": "getModulesPaginated(address,uint256)",
	"a0e67e2b": "getOwners()",
	"048a5fed": "getSelfBalance()",
	"5624b25b": "getStorageAt(uint256,uint256)",
	"e75235b8": "getThreshold()",
	"d8d11f78": "getTransactionHash(address,uint256,bytes,uint8,uint256,uint256,uint256,address,address,uint256)",
	"2d9ad53d": "isModuleEnabled(address)",
	"2f54bf6e": "isOwner(address)",
	"affed0e0": "nonce()",
	"f8dc5dd9": "removeOwner(address,address,uint256)",
	"c4ca3a9c": "requiredTxGas(address,uint256,bytes,uint8)",
	"f08a0323": "setFallbackHandler(address)",
	"b63e800d": "setup(address[],uint256,address,bytes,address,address,uint256,address)",
	"85a5affe": "signMessage(bytes)",
	"5ae6bd37": "signedMessages(bytes32)",
	"f84436bd": "simulateDelegatecall(address,bytes)",
	"43218e19": "simulateDelegatecallInternal(address,bytes)",
	"e318b52b": "swapOwner(address,address,address)",
}

GnosisSafeFuncSigs maps the 4-byte function signature to its string representation.

View Source 
var GnosisSafeMathBin = "" /* 244-byte string literal not displayed */

GnosisSafeMathBin is the compiled bytecode used for deploying new contracts.

View Source 
var ISignatureValidatorConstantsBin = "" /* 186-byte string literal not displayed */

ISignatureValidatorConstantsBin is the compiled bytecode used for deploying new contracts.

View Source 
var ISignatureValidatorFuncSigs = map[string]string{
	"20c13b0b": "isValidSignature(bytes,bytes)",
}

ISignatureValidatorFuncSigs maps the 4-byte function signature to its string representation.

View Source 
var ModuleManagerBin = "" /* 5082-byte string literal not displayed */

ModuleManagerBin is the compiled bytecode used for deploying new contracts.

View Source 
var ModuleManagerFuncSigs = map[string]string{
	"e009cfde": "disableModule(address,address)",
	"610b5925": "enableModule(address)",
	"468721a7": "execTransactionFromModule(address,uint256,bytes,uint8)",
	"5229073f": "execTransactionFromModuleReturnData(address,uint256,bytes,uint8)",
	"cc2f8452": "getModulesPaginated(address,uint256)",
	"2d9ad53d": "isModuleEnabled(address)",
}

ModuleManagerFuncSigs maps the 4-byte function signature to its string representation.

View Source 
var OwnerManagerBin = "" /* 5632-byte string literal not displayed */

OwnerManagerBin is the compiled bytecode used for deploying new contracts.

View Source 
var OwnerManagerFuncSigs = map[string]string{
	"0d582f13": "addOwnerWithThreshold(address,uint256)",
	"694e80c3": "changeThreshold(uint256)",
	"a0e67e2b": "getOwners()",
	"e75235b8": "getThreshold()",
	"2f54bf6e": "isOwner(address)",
	"f8dc5dd9": "removeOwner(address,address,uint256)",
	"e318b52b": "swapOwner(address,address,address)",
}

OwnerManagerFuncSigs maps the 4-byte function signature to its string representation.

View Source 
var SecuredTokenTransferBin = "" /* 186-byte string literal not displayed */

SecuredTokenTransferBin is the compiled bytecode used for deploying new contracts.

View Source 
var SelfAuthorizedBin = "" /* 186-byte string literal not displayed */

SelfAuthorizedBin is the compiled bytecode used for deploying new contracts.

View Source 
var SignatureDecoderBin = "" /* 186-byte string literal not displayed */

SignatureDecoderBin is the compiled bytecode used for deploying new contracts.

View Source 
var SingletonBin = "" /* 186-byte string literal not displayed */

SingletonBin is the compiled bytecode used for deploying new contracts.

View Source 
var StorageAccessibleBin = "" /* 3150-byte string literal not displayed */

StorageAccessibleBin is the compiled bytecode used for deploying new contracts.

View Source 
var StorageAccessibleFuncSigs = map[string]string{
	"5624b25b": "getStorageAt(uint256,uint256)",
	"f84436bd": "simulateDelegatecall(address,bytes)",
	"43218e19": "simulateDelegatecallInternal(address,bytes)",
}

StorageAccessibleFuncSigs maps the 4-byte function signature to its string representation.

Functions

This section is empty.

Types

type Enum 

type Enum struct {
	EnumCaller     // Read-only binding to the contract
	EnumTransactor // Write-only binding to the contract
	EnumFilterer   // Log filterer for contract events
}

Enum is an auto generated Go binding around an Ethereum contract.

func DeployEnum 

func DeployEnum(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Enum, error)

DeployEnum deploys a new Ethereum contract, binding an instance of Enum to it.

func NewEnum 

func NewEnum(address common.Address, backend bind.ContractBackend) (*Enum, error)

NewEnum creates a new instance of Enum, bound to a specific deployed contract.

type EnumCaller 

type EnumCaller struct {
	// contains filtered or unexported fields
}

EnumCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewEnumCaller 

func NewEnumCaller(address common.Address, caller bind.ContractCaller) (*EnumCaller, error)

NewEnumCaller creates a new read-only instance of Enum, bound to a specific deployed contract.

type EnumCallerRaw 

type EnumCallerRaw struct {
	Contract *EnumCaller // Generic read-only contract binding to access the raw methods on
}

EnumCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*EnumCallerRaw) Call 

func (_Enum *EnumCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type EnumCallerSession 

type EnumCallerSession struct {
	Contract *EnumCaller   // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts // Call options to use throughout this session
}

EnumCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type EnumFilterer 

type EnumFilterer struct {
	// contains filtered or unexported fields
}

EnumFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewEnumFilterer 

func NewEnumFilterer(address common.Address, filterer bind.ContractFilterer) (*EnumFilterer, error)

NewEnumFilterer creates a new log filterer instance of Enum, bound to a specific deployed contract.

type EnumRaw 

type EnumRaw struct {
	Contract *Enum // Generic contract binding to access the raw methods on
}

EnumRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*EnumRaw) Call 

func (_Enum *EnumRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*EnumRaw) Transact 

func (_Enum *EnumRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*EnumRaw) Transfer 

func (_Enum *EnumRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type EnumSession 

type EnumSession struct {
	Contract     *Enum             // 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
}

EnumSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type EnumTransactor 

type EnumTransactor struct {
	// contains filtered or unexported fields
}

EnumTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewEnumTransactor 

func NewEnumTransactor(address common.Address, transactor bind.ContractTransactor) (*EnumTransactor, error)

NewEnumTransactor creates a new write-only instance of Enum, bound to a specific deployed contract.

type EnumTransactorRaw 

type EnumTransactorRaw struct {
	Contract *EnumTransactor // Generic write-only contract binding to access the raw methods on
}

EnumTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*EnumTransactorRaw) Transact 

func (_Enum *EnumTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*EnumTransactorRaw) Transfer 

func (_Enum *EnumTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type EnumTransactorSession 

type EnumTransactorSession struct {
	Contract     *EnumTransactor   // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

EnumTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type EtherPaymentFallback 

type EtherPaymentFallback struct {
	EtherPaymentFallbackCaller     // Read-only binding to the contract
	EtherPaymentFallbackTransactor // Write-only binding to the contract
	EtherPaymentFallbackFilterer   // Log filterer for contract events
}

EtherPaymentFallback is an auto generated Go binding around an Ethereum contract.

func DeployEtherPaymentFallback 

func DeployEtherPaymentFallback(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *EtherPaymentFallback, error)

DeployEtherPaymentFallback deploys a new Ethereum contract, binding an instance of EtherPaymentFallback to it.

func NewEtherPaymentFallback 

func NewEtherPaymentFallback(address common.Address, backend bind.ContractBackend) (*EtherPaymentFallback, error)

NewEtherPaymentFallback creates a new instance of EtherPaymentFallback, bound to a specific deployed contract.

type EtherPaymentFallbackCaller 

type EtherPaymentFallbackCaller struct {
	// contains filtered or unexported fields
}

EtherPaymentFallbackCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewEtherPaymentFallbackCaller 

func NewEtherPaymentFallbackCaller(address common.Address, caller bind.ContractCaller) (*EtherPaymentFallbackCaller, error)

NewEtherPaymentFallbackCaller creates a new read-only instance of EtherPaymentFallback, bound to a specific deployed contract.

type EtherPaymentFallbackCallerRaw 

type EtherPaymentFallbackCallerRaw struct {
	Contract *EtherPaymentFallbackCaller // Generic read-only contract binding to access the raw methods on
}

EtherPaymentFallbackCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*EtherPaymentFallbackCallerRaw) Call 

func (_EtherPaymentFallback *EtherPaymentFallbackCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type EtherPaymentFallbackCallerSession 

type EtherPaymentFallbackCallerSession struct {
	Contract *EtherPaymentFallbackCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts               // Call options to use throughout this session
}

EtherPaymentFallbackCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type EtherPaymentFallbackFilterer 

type EtherPaymentFallbackFilterer struct {
	// contains filtered or unexported fields
}

EtherPaymentFallbackFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewEtherPaymentFallbackFilterer 

func NewEtherPaymentFallbackFilterer(address common.Address, filterer bind.ContractFilterer) (*EtherPaymentFallbackFilterer, error)

NewEtherPaymentFallbackFilterer creates a new log filterer instance of EtherPaymentFallback, bound to a specific deployed contract.

type EtherPaymentFallbackRaw 

type EtherPaymentFallbackRaw struct {
	Contract *EtherPaymentFallback // Generic contract binding to access the raw methods on
}

EtherPaymentFallbackRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*EtherPaymentFallbackRaw) Call 

func (_EtherPaymentFallback *EtherPaymentFallbackRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*EtherPaymentFallbackRaw) Transact 

func (_EtherPaymentFallback *EtherPaymentFallbackRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*EtherPaymentFallbackRaw) Transfer 

func (_EtherPaymentFallback *EtherPaymentFallbackRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type EtherPaymentFallbackSession 

type EtherPaymentFallbackSession struct {
	Contract     *EtherPaymentFallback // 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
}

EtherPaymentFallbackSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*EtherPaymentFallbackSession) Receive 

func (_EtherPaymentFallback *EtherPaymentFallbackSession) Receive() (*types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

type EtherPaymentFallbackTransactor 

type EtherPaymentFallbackTransactor struct {
	// contains filtered or unexported fields
}

EtherPaymentFallbackTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewEtherPaymentFallbackTransactor 

func NewEtherPaymentFallbackTransactor(address common.Address, transactor bind.ContractTransactor) (*EtherPaymentFallbackTransactor, error)

NewEtherPaymentFallbackTransactor creates a new write-only instance of EtherPaymentFallback, bound to a specific deployed contract.

func (*EtherPaymentFallbackTransactor) Receive 

func (_EtherPaymentFallback *EtherPaymentFallbackTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

type EtherPaymentFallbackTransactorRaw 

type EtherPaymentFallbackTransactorRaw struct {
	Contract *EtherPaymentFallbackTransactor // Generic write-only contract binding to access the raw methods on
}

EtherPaymentFallbackTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*EtherPaymentFallbackTransactorRaw) Transact 

func (_EtherPaymentFallback *EtherPaymentFallbackTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*EtherPaymentFallbackTransactorRaw) Transfer 

func (_EtherPaymentFallback *EtherPaymentFallbackTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type EtherPaymentFallbackTransactorSession 

type EtherPaymentFallbackTransactorSession struct {
	Contract     *EtherPaymentFallbackTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts               // Transaction auth options to use throughout this session
}

EtherPaymentFallbackTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*EtherPaymentFallbackTransactorSession) Receive 

func (_EtherPaymentFallback *EtherPaymentFallbackTransactorSession) Receive() (*types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

type Executor 

type Executor struct {
	ExecutorCaller     // Read-only binding to the contract
	ExecutorTransactor // Write-only binding to the contract
	ExecutorFilterer   // Log filterer for contract events
}

Executor is an auto generated Go binding around an Ethereum contract.

func DeployExecutor 

func DeployExecutor(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Executor, error)

DeployExecutor deploys a new Ethereum contract, binding an instance of Executor to it.

func NewExecutor 

func NewExecutor(address common.Address, backend bind.ContractBackend) (*Executor, error)

NewExecutor creates a new instance of Executor, bound to a specific deployed contract.

type ExecutorCaller 

type ExecutorCaller struct {
	// contains filtered or unexported fields
}

ExecutorCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewExecutorCaller 

func NewExecutorCaller(address common.Address, caller bind.ContractCaller) (*ExecutorCaller, error)

NewExecutorCaller creates a new read-only instance of Executor, bound to a specific deployed contract.

type ExecutorCallerRaw 

type ExecutorCallerRaw struct {
	Contract *ExecutorCaller // Generic read-only contract binding to access the raw methods on
}

ExecutorCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*ExecutorCallerRaw) Call 

func (_Executor *ExecutorCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type ExecutorCallerSession 

type ExecutorCallerSession struct {
	Contract *ExecutorCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts   // Call options to use throughout this session
}

ExecutorCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type ExecutorFilterer 

type ExecutorFilterer struct {
	// contains filtered or unexported fields
}

ExecutorFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewExecutorFilterer 

func NewExecutorFilterer(address common.Address, filterer bind.ContractFilterer) (*ExecutorFilterer, error)

NewExecutorFilterer creates a new log filterer instance of Executor, bound to a specific deployed contract.

type ExecutorRaw 

type ExecutorRaw struct {
	Contract *Executor // Generic contract binding to access the raw methods on
}

ExecutorRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*ExecutorRaw) Call 

func (_Executor *ExecutorRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*ExecutorRaw) Transact 

func (_Executor *ExecutorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ExecutorRaw) Transfer 

func (_Executor *ExecutorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ExecutorSession 

type ExecutorSession struct {
	Contract     *Executor         // 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
}

ExecutorSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type ExecutorTransactor 

type ExecutorTransactor struct {
	// contains filtered or unexported fields
}

ExecutorTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewExecutorTransactor 

func NewExecutorTransactor(address common.Address, transactor bind.ContractTransactor) (*ExecutorTransactor, error)

NewExecutorTransactor creates a new write-only instance of Executor, bound to a specific deployed contract.

type ExecutorTransactorRaw 

type ExecutorTransactorRaw struct {
	Contract *ExecutorTransactor // Generic write-only contract binding to access the raw methods on
}

ExecutorTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*ExecutorTransactorRaw) Transact 

func (_Executor *ExecutorTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ExecutorTransactorRaw) Transfer 

func (_Executor *ExecutorTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ExecutorTransactorSession 

type ExecutorTransactorSession struct {
	Contract     *ExecutorTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
}

ExecutorTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type FallbackManager 

type FallbackManager struct {
	FallbackManagerCaller     // Read-only binding to the contract
	FallbackManagerTransactor // Write-only binding to the contract
	FallbackManagerFilterer   // Log filterer for contract events
}

FallbackManager is an auto generated Go binding around an Ethereum contract.

func DeployFallbackManager 

func DeployFallbackManager(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *FallbackManager, error)

DeployFallbackManager deploys a new Ethereum contract, binding an instance of FallbackManager to it.

func NewFallbackManager 

func NewFallbackManager(address common.Address, backend bind.ContractBackend) (*FallbackManager, error)

NewFallbackManager creates a new instance of FallbackManager, bound to a specific deployed contract.

type FallbackManagerCaller 

type FallbackManagerCaller struct {
	// contains filtered or unexported fields
}

FallbackManagerCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewFallbackManagerCaller 

func NewFallbackManagerCaller(address common.Address, caller bind.ContractCaller) (*FallbackManagerCaller, error)

NewFallbackManagerCaller creates a new read-only instance of FallbackManager, bound to a specific deployed contract.

type FallbackManagerCallerRaw 

type FallbackManagerCallerRaw struct {
	Contract *FallbackManagerCaller // Generic read-only contract binding to access the raw methods on
}

FallbackManagerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*FallbackManagerCallerRaw) Call 

func (_FallbackManager *FallbackManagerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type FallbackManagerCallerSession 

type FallbackManagerCallerSession struct {
	Contract *FallbackManagerCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts          // Call options to use throughout this session
}

FallbackManagerCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type FallbackManagerFilterer 

type FallbackManagerFilterer struct {
	// contains filtered or unexported fields
}

FallbackManagerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewFallbackManagerFilterer 

func NewFallbackManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*FallbackManagerFilterer, error)

NewFallbackManagerFilterer creates a new log filterer instance of FallbackManager, bound to a specific deployed contract.

type FallbackManagerRaw 

type FallbackManagerRaw struct {
	Contract *FallbackManager // Generic contract binding to access the raw methods on
}

FallbackManagerRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*FallbackManagerRaw) Call 

func (_FallbackManager *FallbackManagerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*FallbackManagerRaw) Transact 

func (_FallbackManager *FallbackManagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*FallbackManagerRaw) Transfer 

func (_FallbackManager *FallbackManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type FallbackManagerSession 

type FallbackManagerSession struct {
	Contract     *FallbackManager  // 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
}

FallbackManagerSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*FallbackManagerSession) Fallback 

func (_FallbackManager *FallbackManagerSession) Fallback(calldata []byte) (*types.Transaction, error)

Fallback is a paid mutator transaction binding the contract fallback function.

Solidity: fallback() returns()

func (*FallbackManagerSession) SetFallbackHandler 

func (_FallbackManager *FallbackManagerSession) SetFallbackHandler(handler common.Address) (*types.Transaction, error)

SetFallbackHandler is a paid mutator transaction binding the contract method 0xf08a0323.

Solidity: function setFallbackHandler(address handler) returns()

type FallbackManagerTransactor 

type FallbackManagerTransactor struct {
	// contains filtered or unexported fields
}

FallbackManagerTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewFallbackManagerTransactor 

func NewFallbackManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*FallbackManagerTransactor, error)

NewFallbackManagerTransactor creates a new write-only instance of FallbackManager, bound to a specific deployed contract.

func (*FallbackManagerTransactor) Fallback 

func (_FallbackManager *FallbackManagerTransactor) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error)

Fallback is a paid mutator transaction binding the contract fallback function.

Solidity: fallback() returns()

func (*FallbackManagerTransactor) SetFallbackHandler 

func (_FallbackManager *FallbackManagerTransactor) SetFallbackHandler(opts *bind.TransactOpts, handler common.Address) (*types.Transaction, error)

SetFallbackHandler is a paid mutator transaction binding the contract method 0xf08a0323.

Solidity: function setFallbackHandler(address handler) returns()

type FallbackManagerTransactorRaw 

type FallbackManagerTransactorRaw struct {
	Contract *FallbackManagerTransactor // Generic write-only contract binding to access the raw methods on
}

FallbackManagerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*FallbackManagerTransactorRaw) Transact 

func (_FallbackManager *FallbackManagerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*FallbackManagerTransactorRaw) Transfer 

func (_FallbackManager *FallbackManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type FallbackManagerTransactorSession 

type FallbackManagerTransactorSession struct {
	Contract     *FallbackManagerTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts          // Transaction auth options to use throughout this session
}

FallbackManagerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*FallbackManagerTransactorSession) Fallback 

func (_FallbackManager *FallbackManagerTransactorSession) Fallback(calldata []byte) (*types.Transaction, error)

Fallback is a paid mutator transaction binding the contract fallback function.

Solidity: fallback() returns()

func (*FallbackManagerTransactorSession) SetFallbackHandler 

func (_FallbackManager *FallbackManagerTransactorSession) SetFallbackHandler(handler common.Address) (*types.Transaction, error)

SetFallbackHandler is a paid mutator transaction binding the contract method 0xf08a0323.

Solidity: function setFallbackHandler(address handler) returns()

type GnosisSafe 

type GnosisSafe struct {
	GnosisSafeCaller     // Read-only binding to the contract
	GnosisSafeTransactor // Write-only binding to the contract
	GnosisSafeFilterer   // Log filterer for contract events
}

GnosisSafe is an auto generated Go binding around an Ethereum contract.

func DeployGnosisSafe 

func DeployGnosisSafe(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *GnosisSafe, error)

DeployGnosisSafe deploys a new Ethereum contract, binding an instance of GnosisSafe to it.

func NewGnosisSafe 

func NewGnosisSafe(address common.Address, backend bind.ContractBackend) (*GnosisSafe, error)

NewGnosisSafe creates a new instance of GnosisSafe, bound to a specific deployed contract.

type GnosisSafeAddedOwner 

type GnosisSafeAddedOwner struct {
	Owner common.Address
	Raw   types.Log // Blockchain specific contextual infos
}

GnosisSafeAddedOwner represents a AddedOwner event raised by the GnosisSafe contract.

type GnosisSafeAddedOwnerIterator 

type GnosisSafeAddedOwnerIterator struct {
	Event *GnosisSafeAddedOwner // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

GnosisSafeAddedOwnerIterator is returned from FilterAddedOwner and is used to iterate over the raw logs and unpacked data for AddedOwner events raised by the GnosisSafe contract.

func (*GnosisSafeAddedOwnerIterator) Close 

func (it *GnosisSafeAddedOwnerIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*GnosisSafeAddedOwnerIterator) Error 

func (it *GnosisSafeAddedOwnerIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*GnosisSafeAddedOwnerIterator) Next 

func (it *GnosisSafeAddedOwnerIterator) Next() bool

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.

type GnosisSafeApproveHash 

type GnosisSafeApproveHash struct {
	ApprovedHash [32]byte
	Owner        common.Address
	Raw          types.Log // Blockchain specific contextual infos
}

GnosisSafeApproveHash represents a ApproveHash event raised by the GnosisSafe contract.

type GnosisSafeApproveHashIterator 

type GnosisSafeApproveHashIterator struct {
	Event *GnosisSafeApproveHash // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

GnosisSafeApproveHashIterator is returned from FilterApproveHash and is used to iterate over the raw logs and unpacked data for ApproveHash events raised by the GnosisSafe contract.

func (*GnosisSafeApproveHashIterator) Close 

func (it *GnosisSafeApproveHashIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*GnosisSafeApproveHashIterator) Error 

func (it *GnosisSafeApproveHashIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*GnosisSafeApproveHashIterator) Next 

func (it *GnosisSafeApproveHashIterator) Next() bool

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.

type GnosisSafeCaller 

type GnosisSafeCaller struct {
	// contains filtered or unexported fields
}

GnosisSafeCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewGnosisSafeCaller 

func NewGnosisSafeCaller(address common.Address, caller bind.ContractCaller) (*GnosisSafeCaller, error)

NewGnosisSafeCaller creates a new read-only instance of GnosisSafe, bound to a specific deployed contract.

func (*GnosisSafeCaller) ApprovedHashes 

func (_GnosisSafe *GnosisSafeCaller) ApprovedHashes(opts *bind.CallOpts, arg0 common.Address, arg1 [32]byte) (*big.Int, error)

ApprovedHashes is a free data retrieval call binding the contract method 0x7d832974.

Solidity: function approvedHashes(address , bytes32 ) view returns(uint256)

func (*GnosisSafeCaller) DomainSeparator 

func (_GnosisSafe *GnosisSafeCaller) DomainSeparator(opts *bind.CallOpts) ([32]byte, error)

DomainSeparator is a free data retrieval call binding the contract method 0xf698da25.

Solidity: function domainSeparator() view returns(bytes32)

func (*GnosisSafeCaller) EncodeTransactionData 

func (_GnosisSafe *GnosisSafeCaller) EncodeTransactionData(opts *bind.CallOpts, to common.Address, value *big.Int, data []byte, operation uint8, safeTxGas *big.Int, baseGas *big.Int, gasPrice *big.Int, gasToken common.Address, refundReceiver common.Address, _nonce *big.Int) ([]byte, error)

EncodeTransactionData is a free data retrieval call binding the contract method 0xe86637db.

Solidity: function encodeTransactionData(address to, uint256 value, bytes data, uint8 operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address refundReceiver, uint256 _nonce) view returns(bytes)

func (*GnosisSafeCaller) GetChainId 

func (_GnosisSafe *GnosisSafeCaller) GetChainId(opts *bind.CallOpts) (*big.Int, error)

GetChainId is a free data retrieval call binding the contract method 0x3408e470.

Solidity: function getChainId() view returns(uint256)

func (*GnosisSafeCaller) GetMessageHash 

func (_GnosisSafe *GnosisSafeCaller) GetMessageHash(opts *bind.CallOpts, message []byte) ([32]byte, error)

GetMessageHash is a free data retrieval call binding the contract method 0x0a1028c4.

Solidity: function getMessageHash(bytes message) view returns(bytes32)

func (*GnosisSafeCaller) GetModulesPaginated 

func (_GnosisSafe *GnosisSafeCaller) GetModulesPaginated(opts *bind.CallOpts, start common.Address, pageSize *big.Int) (struct {
	Array []common.Address
	Next  common.Address
}, error)

GetModulesPaginated is a free data retrieval call binding the contract method 0xcc2f8452.

Solidity: function getModulesPaginated(address start, uint256 pageSize) view returns(address[] array, address next)

func (*GnosisSafeCaller) GetOwners 

func (_GnosisSafe *GnosisSafeCaller) GetOwners(opts *bind.CallOpts) ([]common.Address, error)

GetOwners is a free data retrieval call binding the contract method 0xa0e67e2b.

Solidity: function getOwners() view returns(address[])

func (*GnosisSafeCaller) GetSelfBalance 

func (_GnosisSafe *GnosisSafeCaller) GetSelfBalance(opts *bind.CallOpts) (*big.Int, error)

GetSelfBalance is a free data retrieval call binding the contract method 0x048a5fed.

Solidity: function getSelfBalance() view returns(uint256)

func (*GnosisSafeCaller) GetStorageAt 

func (_GnosisSafe *GnosisSafeCaller) GetStorageAt(opts *bind.CallOpts, offset *big.Int, length *big.Int) ([]byte, error)

GetStorageAt is a free data retrieval call binding the contract method 0x5624b25b.

Solidity: function getStorageAt(uint256 offset, uint256 length) view returns(bytes)

func (*GnosisSafeCaller) GetThreshold 

func (_GnosisSafe *GnosisSafeCaller) GetThreshold(opts *bind.CallOpts) (*big.Int, error)

GetThreshold is a free data retrieval call binding the contract method 0xe75235b8.

Solidity: function getThreshold() view returns(uint256)

func (*GnosisSafeCaller) GetTransactionHash 

func (_GnosisSafe *GnosisSafeCaller) GetTransactionHash(opts *bind.CallOpts, to common.Address, value *big.Int, data []byte, operation uint8, safeTxGas *big.Int, baseGas *big.Int, gasPrice *big.Int, gasToken common.Address, refundReceiver common.Address, _nonce *big.Int) ([32]byte, error)

GetTransactionHash is a free data retrieval call binding the contract method 0xd8d11f78.

Solidity: function getTransactionHash(address to, uint256 value, bytes data, uint8 operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address refundReceiver, uint256 _nonce) view returns(bytes32)

func (*GnosisSafeCaller) IsModuleEnabled 

func (_GnosisSafe *GnosisSafeCaller) IsModuleEnabled(opts *bind.CallOpts, module common.Address) (bool, error)

IsModuleEnabled is a free data retrieval call binding the contract method 0x2d9ad53d.

Solidity: function isModuleEnabled(address module) view returns(bool)

func (*GnosisSafeCaller) IsOwner 

func (_GnosisSafe *GnosisSafeCaller) IsOwner(opts *bind.CallOpts, owner common.Address) (bool, error)

IsOwner is a free data retrieval call binding the contract method 0x2f54bf6e.

Solidity: function isOwner(address owner) view returns(bool)

func (*GnosisSafeCaller) NAME 

func (_GnosisSafe *GnosisSafeCaller) NAME(opts *bind.CallOpts) (string, error)

NAME is a free data retrieval call binding the contract method 0xa3f4df7e.

Solidity: function NAME() view returns(string)

func (*GnosisSafeCaller) Nonce 

func (_GnosisSafe *GnosisSafeCaller) Nonce(opts *bind.CallOpts) (*big.Int, error)

Nonce is a free data retrieval call binding the contract method 0xaffed0e0.

Solidity: function nonce() view returns(uint256)

func (*GnosisSafeCaller) SignedMessages 

func (_GnosisSafe *GnosisSafeCaller) SignedMessages(opts *bind.CallOpts, arg0 [32]byte) (*big.Int, error)

SignedMessages is a free data retrieval call binding the contract method 0x5ae6bd37.

Solidity: function signedMessages(bytes32 ) view returns(uint256)

func (*GnosisSafeCaller) VERSION 

func (_GnosisSafe *GnosisSafeCaller) VERSION(opts *bind.CallOpts) (string, error)

VERSION is a free data retrieval call binding the contract method 0xffa1ad74.

Solidity: function VERSION() view returns(string)

type GnosisSafeCallerRaw 

type GnosisSafeCallerRaw struct {
	Contract *GnosisSafeCaller // Generic read-only contract binding to access the raw methods on
}

GnosisSafeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*GnosisSafeCallerRaw) Call 

func (_GnosisSafe *GnosisSafeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type GnosisSafeCallerSession 

type GnosisSafeCallerSession struct {
	Contract *GnosisSafeCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts     // Call options to use throughout this session
}

GnosisSafeCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*GnosisSafeCallerSession) ApprovedHashes 

func (_GnosisSafe *GnosisSafeCallerSession) ApprovedHashes(arg0 common.Address, arg1 [32]byte) (*big.Int, error)

ApprovedHashes is a free data retrieval call binding the contract method 0x7d832974.

Solidity: function approvedHashes(address , bytes32 ) view returns(uint256)

func (*GnosisSafeCallerSession) DomainSeparator 

func (_GnosisSafe *GnosisSafeCallerSession) DomainSeparator() ([32]byte, error)

DomainSeparator is a free data retrieval call binding the contract method 0xf698da25.

Solidity: function domainSeparator() view returns(bytes32)

func (*GnosisSafeCallerSession) EncodeTransactionData 

func (_GnosisSafe *GnosisSafeCallerSession) EncodeTransactionData(to common.Address, value *big.Int, data []byte, operation uint8, safeTxGas *big.Int, baseGas *big.Int, gasPrice *big.Int, gasToken common.Address, refundReceiver common.Address, _nonce *big.Int) ([]byte, error)

EncodeTransactionData is a free data retrieval call binding the contract method 0xe86637db.

Solidity: function encodeTransactionData(address to, uint256 value, bytes data, uint8 operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address refundReceiver, uint256 _nonce) view returns(bytes)

func (*GnosisSafeCallerSession) GetChainId 

func (_GnosisSafe *GnosisSafeCallerSession) GetChainId() (*big.Int, error)

GetChainId is a free data retrieval call binding the contract method 0x3408e470.

Solidity: function getChainId() view returns(uint256)

func (*GnosisSafeCallerSession) GetMessageHash 

func (_GnosisSafe *GnosisSafeCallerSession) GetMessageHash(message []byte) ([32]byte, error)

GetMessageHash is a free data retrieval call binding the contract method 0x0a1028c4.

Solidity: function getMessageHash(bytes message) view returns(bytes32)

func (*GnosisSafeCallerSession) GetModulesPaginated 

func (_GnosisSafe *GnosisSafeCallerSession) GetModulesPaginated(start common.Address, pageSize *big.Int) (struct {
	Array []common.Address
	Next  common.Address
}, error)

GetModulesPaginated is a free data retrieval call binding the contract method 0xcc2f8452.

Solidity: function getModulesPaginated(address start, uint256 pageSize) view returns(address[] array, address next)

func (*GnosisSafeCallerSession) GetOwners 

func (_GnosisSafe *GnosisSafeCallerSession) GetOwners() ([]common.Address, error)

GetOwners is a free data retrieval call binding the contract method 0xa0e67e2b.

Solidity: function getOwners() view returns(address[])

func (*GnosisSafeCallerSession) GetSelfBalance 

func (_GnosisSafe *GnosisSafeCallerSession) GetSelfBalance() (*big.Int, error)

GetSelfBalance is a free data retrieval call binding the contract method 0x048a5fed.

Solidity: function getSelfBalance() view returns(uint256)

func (*GnosisSafeCallerSession) GetStorageAt 

func (_GnosisSafe *GnosisSafeCallerSession) GetStorageAt(offset *big.Int, length *big.Int) ([]byte, error)

GetStorageAt is a free data retrieval call binding the contract method 0x5624b25b.

Solidity: function getStorageAt(uint256 offset, uint256 length) view returns(bytes)

func (*GnosisSafeCallerSession) GetThreshold 

func (_GnosisSafe *GnosisSafeCallerSession) GetThreshold() (*big.Int, error)

GetThreshold is a free data retrieval call binding the contract method 0xe75235b8.

Solidity: function getThreshold() view returns(uint256)

func (*GnosisSafeCallerSession) GetTransactionHash 

func (_GnosisSafe *GnosisSafeCallerSession) GetTransactionHash(to common.Address, value *big.Int, data []byte, operation uint8, safeTxGas *big.Int, baseGas *big.Int, gasPrice *big.Int, gasToken common.Address, refundReceiver common.Address, _nonce *big.Int) ([32]byte, error)

GetTransactionHash is a free data retrieval call binding the contract method 0xd8d11f78.

Solidity: function getTransactionHash(address to, uint256 value, bytes data, uint8 operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address refundReceiver, uint256 _nonce) view returns(bytes32)

func (*GnosisSafeCallerSession) IsModuleEnabled 

func (_GnosisSafe *GnosisSafeCallerSession) IsModuleEnabled(module common.Address) (bool, error)

IsModuleEnabled is a free data retrieval call binding the contract method 0x2d9ad53d.

Solidity: function isModuleEnabled(address module) view returns(bool)

func (*GnosisSafeCallerSession) IsOwner 

func (_GnosisSafe *GnosisSafeCallerSession) IsOwner(owner common.Address) (bool, error)

IsOwner is a free data retrieval call binding the contract method 0x2f54bf6e.

Solidity: function isOwner(address owner) view returns(bool)

func (*GnosisSafeCallerSession) NAME 

func (_GnosisSafe *GnosisSafeCallerSession) NAME() (string, error)

NAME is a free data retrieval call binding the contract method 0xa3f4df7e.

Solidity: function NAME() view returns(string)

func (*GnosisSafeCallerSession) Nonce 

func (_GnosisSafe *GnosisSafeCallerSession) Nonce() (*big.Int, error)

Nonce is a free data retrieval call binding the contract method 0xaffed0e0.

Solidity: function nonce() view returns(uint256)

func (*GnosisSafeCallerSession) SignedMessages 

func (_GnosisSafe *GnosisSafeCallerSession) SignedMessages(arg0 [32]byte) (*big.Int, error)

SignedMessages is a free data retrieval call binding the contract method 0x5ae6bd37.

Solidity: function signedMessages(bytes32 ) view returns(uint256)

func (*GnosisSafeCallerSession) VERSION 

func (_GnosisSafe *GnosisSafeCallerSession) VERSION() (string, error)

VERSION is a free data retrieval call binding the contract method 0xffa1ad74.

Solidity: function VERSION() view returns(string)

type GnosisSafeChangedThreshold 

type GnosisSafeChangedThreshold struct {
	Threshold *big.Int
	Raw       types.Log // Blockchain specific contextual infos
}

GnosisSafeChangedThreshold represents a ChangedThreshold event raised by the GnosisSafe contract.

type GnosisSafeChangedThresholdIterator 

type GnosisSafeChangedThresholdIterator struct {
	Event *GnosisSafeChangedThreshold // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

GnosisSafeChangedThresholdIterator is returned from FilterChangedThreshold and is used to iterate over the raw logs and unpacked data for ChangedThreshold events raised by the GnosisSafe contract.

func (*GnosisSafeChangedThresholdIterator) Close 

func (it *GnosisSafeChangedThresholdIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*GnosisSafeChangedThresholdIterator) Error 

func (it *GnosisSafeChangedThresholdIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*GnosisSafeChangedThresholdIterator) Next 

func (it *GnosisSafeChangedThresholdIterator) Next() bool

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.

type GnosisSafeDisabledModule 

type GnosisSafeDisabledModule struct {
	Module common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

GnosisSafeDisabledModule represents a DisabledModule event raised by the GnosisSafe contract.

type GnosisSafeDisabledModuleIterator 

type GnosisSafeDisabledModuleIterator struct {
	Event *GnosisSafeDisabledModule // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

GnosisSafeDisabledModuleIterator is returned from FilterDisabledModule and is used to iterate over the raw logs and unpacked data for DisabledModule events raised by the GnosisSafe contract.

func (*GnosisSafeDisabledModuleIterator) Close 

func (it *GnosisSafeDisabledModuleIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*GnosisSafeDisabledModuleIterator) Error 

func (it *GnosisSafeDisabledModuleIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*GnosisSafeDisabledModuleIterator) Next 

func (it *GnosisSafeDisabledModuleIterator) Next() bool

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.

type GnosisSafeEnabledModule 

type GnosisSafeEnabledModule struct {
	Module common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

GnosisSafeEnabledModule represents a EnabledModule event raised by the GnosisSafe contract.

type GnosisSafeEnabledModuleIterator 

type GnosisSafeEnabledModuleIterator struct {
	Event *GnosisSafeEnabledModule // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

GnosisSafeEnabledModuleIterator is returned from FilterEnabledModule and is used to iterate over the raw logs and unpacked data for EnabledModule events raised by the GnosisSafe contract.

func (*GnosisSafeEnabledModuleIterator) Close 

func (it *GnosisSafeEnabledModuleIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*GnosisSafeEnabledModuleIterator) Error 

func (it *GnosisSafeEnabledModuleIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*GnosisSafeEnabledModuleIterator) Next 

func (it *GnosisSafeEnabledModuleIterator) Next() bool

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.

type GnosisSafeExecutionFailure 

type GnosisSafeExecutionFailure struct {
	TxHash  [32]byte
	Payment *big.Int
	Raw     types.Log // Blockchain specific contextual infos
}

GnosisSafeExecutionFailure represents a ExecutionFailure event raised by the GnosisSafe contract.

type GnosisSafeExecutionFailureIterator 

type GnosisSafeExecutionFailureIterator struct {
	Event *GnosisSafeExecutionFailure // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

GnosisSafeExecutionFailureIterator is returned from FilterExecutionFailure and is used to iterate over the raw logs and unpacked data for ExecutionFailure events raised by the GnosisSafe contract.

func (*GnosisSafeExecutionFailureIterator) Close 

func (it *GnosisSafeExecutionFailureIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*GnosisSafeExecutionFailureIterator) Error 

func (it *GnosisSafeExecutionFailureIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*GnosisSafeExecutionFailureIterator) Next 

func (it *GnosisSafeExecutionFailureIterator) Next() bool

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.

type GnosisSafeExecutionFromModuleFailure 

type GnosisSafeExecutionFromModuleFailure struct {
	Module common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

GnosisSafeExecutionFromModuleFailure represents a ExecutionFromModuleFailure event raised by the GnosisSafe contract.

type GnosisSafeExecutionFromModuleFailureIterator 

type GnosisSafeExecutionFromModuleFailureIterator struct {
	Event *GnosisSafeExecutionFromModuleFailure // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

GnosisSafeExecutionFromModuleFailureIterator is returned from FilterExecutionFromModuleFailure and is used to iterate over the raw logs and unpacked data for ExecutionFromModuleFailure events raised by the GnosisSafe contract.

func (*GnosisSafeExecutionFromModuleFailureIterator) Close 

func (it *GnosisSafeExecutionFromModuleFailureIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*GnosisSafeExecutionFromModuleFailureIterator) Error 

func (it *GnosisSafeExecutionFromModuleFailureIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*GnosisSafeExecutionFromModuleFailureIterator) Next 

func (it *GnosisSafeExecutionFromModuleFailureIterator) Next() bool

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.

type GnosisSafeExecutionFromModuleSuccess 

type GnosisSafeExecutionFromModuleSuccess struct {
	Module common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

GnosisSafeExecutionFromModuleSuccess represents a ExecutionFromModuleSuccess event raised by the GnosisSafe contract.

type GnosisSafeExecutionFromModuleSuccessIterator 

type GnosisSafeExecutionFromModuleSuccessIterator struct {
	Event *GnosisSafeExecutionFromModuleSuccess // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

GnosisSafeExecutionFromModuleSuccessIterator is returned from FilterExecutionFromModuleSuccess and is used to iterate over the raw logs and unpacked data for ExecutionFromModuleSuccess events raised by the GnosisSafe contract.

func (*GnosisSafeExecutionFromModuleSuccessIterator) Close 

func (it *GnosisSafeExecutionFromModuleSuccessIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*GnosisSafeExecutionFromModuleSuccessIterator) Error 

func (it *GnosisSafeExecutionFromModuleSuccessIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*GnosisSafeExecutionFromModuleSuccessIterator) Next 

func (it *GnosisSafeExecutionFromModuleSuccessIterator) Next() bool

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.

type GnosisSafeExecutionResult 

type GnosisSafeExecutionResult struct {
	Name   string
	Result bool
	Raw    types.Log // Blockchain specific contextual infos
}

GnosisSafeExecutionResult represents a ExecutionResult event raised by the GnosisSafe contract.

type GnosisSafeExecutionResultIterator 

type GnosisSafeExecutionResultIterator struct {
	Event *GnosisSafeExecutionResult // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

GnosisSafeExecutionResultIterator is returned from FilterExecutionResult and is used to iterate over the raw logs and unpacked data for ExecutionResult events raised by the GnosisSafe contract.

func (*GnosisSafeExecutionResultIterator) Close 

func (it *GnosisSafeExecutionResultIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*GnosisSafeExecutionResultIterator) Error 

func (it *GnosisSafeExecutionResultIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*GnosisSafeExecutionResultIterator) Next 

func (it *GnosisSafeExecutionResultIterator) Next() bool

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.

type GnosisSafeExecutionSuccess 

type GnosisSafeExecutionSuccess struct {
	TxHash  [32]byte
	Payment *big.Int
	Raw     types.Log // Blockchain specific contextual infos
}

GnosisSafeExecutionSuccess represents a ExecutionSuccess event raised by the GnosisSafe contract.

type GnosisSafeExecutionSuccessIterator 

type GnosisSafeExecutionSuccessIterator struct {
	Event *GnosisSafeExecutionSuccess // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

GnosisSafeExecutionSuccessIterator is returned from FilterExecutionSuccess and is used to iterate over the raw logs and unpacked data for ExecutionSuccess events raised by the GnosisSafe contract.

func (*GnosisSafeExecutionSuccessIterator) Close 

func (it *GnosisSafeExecutionSuccessIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*GnosisSafeExecutionSuccessIterator) Error 

func (it *GnosisSafeExecutionSuccessIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*GnosisSafeExecutionSuccessIterator) Next 

func (it *GnosisSafeExecutionSuccessIterator) Next() bool

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.

type GnosisSafeFilterer 

type GnosisSafeFilterer struct {
	// contains filtered or unexported fields
}

GnosisSafeFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewGnosisSafeFilterer 

func NewGnosisSafeFilterer(address common.Address, filterer bind.ContractFilterer) (*GnosisSafeFilterer, error)

NewGnosisSafeFilterer creates a new log filterer instance of GnosisSafe, bound to a specific deployed contract.

func (*GnosisSafeFilterer) FilterAddedOwner 

func (_GnosisSafe *GnosisSafeFilterer) FilterAddedOwner(opts *bind.FilterOpts) (*GnosisSafeAddedOwnerIterator, error)

FilterAddedOwner is a free log retrieval operation binding the contract event 0x9465fa0c962cc76958e6373a993326400c1c94f8be2fe3a952adfa7f60b2ea26.

Solidity: event AddedOwner(address owner)

func (*GnosisSafeFilterer) FilterApproveHash 

func (_GnosisSafe *GnosisSafeFilterer) FilterApproveHash(opts *bind.FilterOpts, approvedHash [][32]byte, owner []common.Address) (*GnosisSafeApproveHashIterator, error)

FilterApproveHash is a free log retrieval operation binding the contract event 0xf2a0eb156472d1440255b0d7c1e19cc07115d1051fe605b0dce69acfec884d9c.

Solidity: event ApproveHash(bytes32 indexed approvedHash, address indexed owner)

func (*GnosisSafeFilterer) FilterChangedThreshold 

func (_GnosisSafe *GnosisSafeFilterer) FilterChangedThreshold(opts *bind.FilterOpts) (*GnosisSafeChangedThresholdIterator, error)

FilterChangedThreshold is a free log retrieval operation binding the contract event 0x610f7ff2b304ae8903c3de74c60c6ab1f7d6226b3f52c5161905bb5ad4039c93.

Solidity: event ChangedThreshold(uint256 threshold)

func (*GnosisSafeFilterer) FilterDisabledModule 

func (_GnosisSafe *GnosisSafeFilterer) FilterDisabledModule(opts *bind.FilterOpts) (*GnosisSafeDisabledModuleIterator, error)

FilterDisabledModule is a free log retrieval operation binding the contract event 0xaab4fa2b463f581b2b32cb3b7e3b704b9ce37cc209b5fb4d77e593ace4054276.

Solidity: event DisabledModule(address module)

func (*GnosisSafeFilterer) FilterEnabledModule 

func (_GnosisSafe *GnosisSafeFilterer) FilterEnabledModule(opts *bind.FilterOpts) (*GnosisSafeEnabledModuleIterator, error)

FilterEnabledModule is a free log retrieval operation binding the contract event 0xecdf3a3effea5783a3c4c2140e677577666428d44ed9d474a0b3a4c9943f8440.

Solidity: event EnabledModule(address module)

func (*GnosisSafeFilterer) FilterExecutionFailure 

func (_GnosisSafe *GnosisSafeFilterer) FilterExecutionFailure(opts *bind.FilterOpts) (*GnosisSafeExecutionFailureIterator, error)

FilterExecutionFailure is a free log retrieval operation binding the contract event 0x23428b18acfb3ea64b08dc0c1d296ea9c09702c09083ca5272e64d115b687d23.

Solidity: event ExecutionFailure(bytes32 txHash, uint256 payment)

func (*GnosisSafeFilterer) FilterExecutionFromModuleFailure 

func (_GnosisSafe *GnosisSafeFilterer) FilterExecutionFromModuleFailure(opts *bind.FilterOpts, module []common.Address) (*GnosisSafeExecutionFromModuleFailureIterator, error)

FilterExecutionFromModuleFailure is a free log retrieval operation binding the contract event 0xacd2c8702804128fdb0db2bb49f6d127dd0181c13fd45dbfe16de0930e2bd375.

Solidity: event ExecutionFromModuleFailure(address indexed module)

func (*GnosisSafeFilterer) FilterExecutionFromModuleSuccess 

func (_GnosisSafe *GnosisSafeFilterer) FilterExecutionFromModuleSuccess(opts *bind.FilterOpts, module []common.Address) (*GnosisSafeExecutionFromModuleSuccessIterator, error)

FilterExecutionFromModuleSuccess is a free log retrieval operation binding the contract event 0x6895c13664aa4f67288b25d7a21d7aaa34916e355fb9b6fae0a139a9085becb8.

Solidity: event ExecutionFromModuleSuccess(address indexed module)

func (*GnosisSafeFilterer) FilterExecutionResult 

func (_GnosisSafe *GnosisSafeFilterer) FilterExecutionResult(opts *bind.FilterOpts) (*GnosisSafeExecutionResultIterator, error)

FilterExecutionResult is a free log retrieval operation binding the contract event 0x36bd3cb3e572bed2e31aa120b605e9d3cb596f0703790070410c5f0b0ac5e34e.

Solidity: event ExecutionResult(string name, bool result)

func (*GnosisSafeFilterer) FilterExecutionSuccess 

func (_GnosisSafe *GnosisSafeFilterer) FilterExecutionSuccess(opts *bind.FilterOpts) (*GnosisSafeExecutionSuccessIterator, error)

FilterExecutionSuccess is a free log retrieval operation binding the contract event 0x442e715f626346e8c54381002da614f62bee8d27386535b2521ec8540898556e.

Solidity: event ExecutionSuccess(bytes32 txHash, uint256 payment)

func (*GnosisSafeFilterer) FilterRemovedOwner 

func (_GnosisSafe *GnosisSafeFilterer) FilterRemovedOwner(opts *bind.FilterOpts) (*GnosisSafeRemovedOwnerIterator, error)

FilterRemovedOwner is a free log retrieval operation binding the contract event 0xf8d49fc529812e9a7c5c50e69c20f0dccc0db8fa95c98bc58cc9a4f1c1299eaf.

Solidity: event RemovedOwner(address owner)

func (*GnosisSafeFilterer) FilterSignMsg 

func (_GnosisSafe *GnosisSafeFilterer) FilterSignMsg(opts *bind.FilterOpts, msgHash [][32]byte) (*GnosisSafeSignMsgIterator, error)

FilterSignMsg is a free log retrieval operation binding the contract event 0xe7f4675038f4f6034dfcbbb24c4dc08e4ebf10eb9d257d3d02c0f38d122ac6e4.

Solidity: event SignMsg(bytes32 indexed msgHash)

func (*GnosisSafeFilterer) FilterSignatureRecover 

func (_GnosisSafe *GnosisSafeFilterer) FilterSignatureRecover(opts *bind.FilterOpts) (*GnosisSafeSignatureRecoverIterator, error)

FilterSignatureRecover is a free log retrieval operation binding the contract event 0x5a06eb92afc8e6aed01ca739e4a5f3d7b76155d973f4428c2f7316095d98abd3.

Solidity: event SignatureRecover(uint256 index, address owner, bytes32 hash)

func (*GnosisSafeFilterer) ParseAddedOwner 

func (_GnosisSafe *GnosisSafeFilterer) ParseAddedOwner(log types.Log) (*GnosisSafeAddedOwner, error)

ParseAddedOwner is a log parse operation binding the contract event 0x9465fa0c962cc76958e6373a993326400c1c94f8be2fe3a952adfa7f60b2ea26.

Solidity: event AddedOwner(address owner)

func (*GnosisSafeFilterer) ParseApproveHash 

func (_GnosisSafe *GnosisSafeFilterer) ParseApproveHash(log types.Log) (*GnosisSafeApproveHash, error)

ParseApproveHash is a log parse operation binding the contract event 0xf2a0eb156472d1440255b0d7c1e19cc07115d1051fe605b0dce69acfec884d9c.

Solidity: event ApproveHash(bytes32 indexed approvedHash, address indexed owner)

func (*GnosisSafeFilterer) ParseChangedThreshold 

func (_GnosisSafe *GnosisSafeFilterer) ParseChangedThreshold(log types.Log) (*GnosisSafeChangedThreshold, error)

ParseChangedThreshold is a log parse operation binding the contract event 0x610f7ff2b304ae8903c3de74c60c6ab1f7d6226b3f52c5161905bb5ad4039c93.

Solidity: event ChangedThreshold(uint256 threshold)

func (*GnosisSafeFilterer) ParseDisabledModule 

func (_GnosisSafe *GnosisSafeFilterer) ParseDisabledModule(log types.Log) (*GnosisSafeDisabledModule, error)

ParseDisabledModule is a log parse operation binding the contract event 0xaab4fa2b463f581b2b32cb3b7e3b704b9ce37cc209b5fb4d77e593ace4054276.

Solidity: event DisabledModule(address module)

func (*GnosisSafeFilterer) ParseEnabledModule 

func (_GnosisSafe *GnosisSafeFilterer) ParseEnabledModule(log types.Log) (*GnosisSafeEnabledModule, error)

ParseEnabledModule is a log parse operation binding the contract event 0xecdf3a3effea5783a3c4c2140e677577666428d44ed9d474a0b3a4c9943f8440.

Solidity: event EnabledModule(address module)

func (*GnosisSafeFilterer) ParseExecutionFailure 

func (_GnosisSafe *GnosisSafeFilterer) ParseExecutionFailure(log types.Log) (*GnosisSafeExecutionFailure, error)

ParseExecutionFailure is a log parse operation binding the contract event 0x23428b18acfb3ea64b08dc0c1d296ea9c09702c09083ca5272e64d115b687d23.

Solidity: event ExecutionFailure(bytes32 txHash, uint256 payment)

func (*GnosisSafeFilterer) ParseExecutionFromModuleFailure 

func (_GnosisSafe *GnosisSafeFilterer) ParseExecutionFromModuleFailure(log types.Log) (*GnosisSafeExecutionFromModuleFailure, error)

ParseExecutionFromModuleFailure is a log parse operation binding the contract event 0xacd2c8702804128fdb0db2bb49f6d127dd0181c13fd45dbfe16de0930e2bd375.

Solidity: event ExecutionFromModuleFailure(address indexed module)

func (*GnosisSafeFilterer) ParseExecutionFromModuleSuccess 

func (_GnosisSafe *GnosisSafeFilterer) ParseExecutionFromModuleSuccess(log types.Log) (*GnosisSafeExecutionFromModuleSuccess, error)

ParseExecutionFromModuleSuccess is a log parse operation binding the contract event 0x6895c13664aa4f67288b25d7a21d7aaa34916e355fb9b6fae0a139a9085becb8.

Solidity: event ExecutionFromModuleSuccess(address indexed module)

func (*GnosisSafeFilterer) ParseExecutionResult 

func (_GnosisSafe *GnosisSafeFilterer) ParseExecutionResult(log types.Log) (*GnosisSafeExecutionResult, error)

ParseExecutionResult is a log parse operation binding the contract event 0x36bd3cb3e572bed2e31aa120b605e9d3cb596f0703790070410c5f0b0ac5e34e.

Solidity: event ExecutionResult(string name, bool result)

func (*GnosisSafeFilterer) ParseExecutionSuccess 

func (_GnosisSafe *GnosisSafeFilterer) ParseExecutionSuccess(log types.Log) (*GnosisSafeExecutionSuccess, error)

ParseExecutionSuccess is a log parse operation binding the contract event 0x442e715f626346e8c54381002da614f62bee8d27386535b2521ec8540898556e.

Solidity: event ExecutionSuccess(bytes32 txHash, uint256 payment)

func (*GnosisSafeFilterer) ParseRemovedOwner 

func (_GnosisSafe *GnosisSafeFilterer) ParseRemovedOwner(log types.Log) (*GnosisSafeRemovedOwner, error)

ParseRemovedOwner is a log parse operation binding the contract event 0xf8d49fc529812e9a7c5c50e69c20f0dccc0db8fa95c98bc58cc9a4f1c1299eaf.

Solidity: event RemovedOwner(address owner)

func (*GnosisSafeFilterer) ParseSignMsg 

func (_GnosisSafe *GnosisSafeFilterer) ParseSignMsg(log types.Log) (*GnosisSafeSignMsg, error)

ParseSignMsg is a log parse operation binding the contract event 0xe7f4675038f4f6034dfcbbb24c4dc08e4ebf10eb9d257d3d02c0f38d122ac6e4.

Solidity: event SignMsg(bytes32 indexed msgHash)

func (*GnosisSafeFilterer) ParseSignatureRecover 

func (_GnosisSafe *GnosisSafeFilterer) ParseSignatureRecover(log types.Log) (*GnosisSafeSignatureRecover, error)

ParseSignatureRecover is a log parse operation binding the contract event 0x5a06eb92afc8e6aed01ca739e4a5f3d7b76155d973f4428c2f7316095d98abd3.

Solidity: event SignatureRecover(uint256 index, address owner, bytes32 hash)

func (*GnosisSafeFilterer) WatchAddedOwner 

func (_GnosisSafe *GnosisSafeFilterer) WatchAddedOwner(opts *bind.WatchOpts, sink chan<- *GnosisSafeAddedOwner) (event.Subscription, error)

WatchAddedOwner is a free log subscription operation binding the contract event 0x9465fa0c962cc76958e6373a993326400c1c94f8be2fe3a952adfa7f60b2ea26.

Solidity: event AddedOwner(address owner)

func (*GnosisSafeFilterer) WatchApproveHash 

func (_GnosisSafe *GnosisSafeFilterer) WatchApproveHash(opts *bind.WatchOpts, sink chan<- *GnosisSafeApproveHash, approvedHash [][32]byte, owner []common.Address) (event.Subscription, error)

WatchApproveHash is a free log subscription operation binding the contract event 0xf2a0eb156472d1440255b0d7c1e19cc07115d1051fe605b0dce69acfec884d9c.

Solidity: event ApproveHash(bytes32 indexed approvedHash, address indexed owner)

func (*GnosisSafeFilterer) WatchChangedThreshold 

func (_GnosisSafe *GnosisSafeFilterer) WatchChangedThreshold(opts *bind.WatchOpts, sink chan<- *GnosisSafeChangedThreshold) (event.Subscription, error)

WatchChangedThreshold is a free log subscription operation binding the contract event 0x610f7ff2b304ae8903c3de74c60c6ab1f7d6226b3f52c5161905bb5ad4039c93.

Solidity: event ChangedThreshold(uint256 threshold)

func (*GnosisSafeFilterer) WatchDisabledModule 

func (_GnosisSafe *GnosisSafeFilterer) WatchDisabledModule(opts *bind.WatchOpts, sink chan<- *GnosisSafeDisabledModule) (event.Subscription, error)

WatchDisabledModule is a free log subscription operation binding the contract event 0xaab4fa2b463f581b2b32cb3b7e3b704b9ce37cc209b5fb4d77e593ace4054276.

Solidity: event DisabledModule(address module)

func (*GnosisSafeFilterer) WatchEnabledModule 

func (_GnosisSafe *GnosisSafeFilterer) WatchEnabledModule(opts *bind.WatchOpts, sink chan<- *GnosisSafeEnabledModule) (event.Subscription, error)

WatchEnabledModule is a free log subscription operation binding the contract event 0xecdf3a3effea5783a3c4c2140e677577666428d44ed9d474a0b3a4c9943f8440.

Solidity: event EnabledModule(address module)

func (*GnosisSafeFilterer) WatchExecutionFailure 

func (_GnosisSafe *GnosisSafeFilterer) WatchExecutionFailure(opts *bind.WatchOpts, sink chan<- *GnosisSafeExecutionFailure) (event.Subscription, error)

WatchExecutionFailure is a free log subscription operation binding the contract event 0x23428b18acfb3ea64b08dc0c1d296ea9c09702c09083ca5272e64d115b687d23.

Solidity: event ExecutionFailure(bytes32 txHash, uint256 payment)

func (*GnosisSafeFilterer) WatchExecutionFromModuleFailure 

func (_GnosisSafe *GnosisSafeFilterer) WatchExecutionFromModuleFailure(opts *bind.WatchOpts, sink chan<- *GnosisSafeExecutionFromModuleFailure, module []common.Address) (event.Subscription, error)

WatchExecutionFromModuleFailure is a free log subscription operation binding the contract event 0xacd2c8702804128fdb0db2bb49f6d127dd0181c13fd45dbfe16de0930e2bd375.

Solidity: event ExecutionFromModuleFailure(address indexed module)

func (*GnosisSafeFilterer) WatchExecutionFromModuleSuccess 

func (_GnosisSafe *GnosisSafeFilterer) WatchExecutionFromModuleSuccess(opts *bind.WatchOpts, sink chan<- *GnosisSafeExecutionFromModuleSuccess, module []common.Address) (event.Subscription, error)

WatchExecutionFromModuleSuccess is a free log subscription operation binding the contract event 0x6895c13664aa4f67288b25d7a21d7aaa34916e355fb9b6fae0a139a9085becb8.

Solidity: event ExecutionFromModuleSuccess(address indexed module)

func (*GnosisSafeFilterer) WatchExecutionResult 

func (_GnosisSafe *GnosisSafeFilterer) WatchExecutionResult(opts *bind.WatchOpts, sink chan<- *GnosisSafeExecutionResult) (event.Subscription, error)

WatchExecutionResult is a free log subscription operation binding the contract event 0x36bd3cb3e572bed2e31aa120b605e9d3cb596f0703790070410c5f0b0ac5e34e.

Solidity: event ExecutionResult(string name, bool result)

func (*GnosisSafeFilterer) WatchExecutionSuccess 

func (_GnosisSafe *GnosisSafeFilterer) WatchExecutionSuccess(opts *bind.WatchOpts, sink chan<- *GnosisSafeExecutionSuccess) (event.Subscription, error)

WatchExecutionSuccess is a free log subscription operation binding the contract event 0x442e715f626346e8c54381002da614f62bee8d27386535b2521ec8540898556e.

Solidity: event ExecutionSuccess(bytes32 txHash, uint256 payment)

func (*GnosisSafeFilterer) WatchRemovedOwner 

func (_GnosisSafe *GnosisSafeFilterer) WatchRemovedOwner(opts *bind.WatchOpts, sink chan<- *GnosisSafeRemovedOwner) (event.Subscription, error)

WatchRemovedOwner is a free log subscription operation binding the contract event 0xf8d49fc529812e9a7c5c50e69c20f0dccc0db8fa95c98bc58cc9a4f1c1299eaf.

Solidity: event RemovedOwner(address owner)

func (*GnosisSafeFilterer) WatchSignMsg 

func (_GnosisSafe *GnosisSafeFilterer) WatchSignMsg(opts *bind.WatchOpts, sink chan<- *GnosisSafeSignMsg, msgHash [][32]byte) (event.Subscription, error)

WatchSignMsg is a free log subscription operation binding the contract event 0xe7f4675038f4f6034dfcbbb24c4dc08e4ebf10eb9d257d3d02c0f38d122ac6e4.

Solidity: event SignMsg(bytes32 indexed msgHash)

func (*GnosisSafeFilterer) WatchSignatureRecover 

func (_GnosisSafe *GnosisSafeFilterer) WatchSignatureRecover(opts *bind.WatchOpts, sink chan<- *GnosisSafeSignatureRecover) (event.Subscription, error)

WatchSignatureRecover is a free log subscription operation binding the contract event 0x5a06eb92afc8e6aed01ca739e4a5f3d7b76155d973f4428c2f7316095d98abd3.

Solidity: event SignatureRecover(uint256 index, address owner, bytes32 hash)

type GnosisSafeMath 

type GnosisSafeMath struct {
	GnosisSafeMathCaller     // Read-only binding to the contract
	GnosisSafeMathTransactor // Write-only binding to the contract
	GnosisSafeMathFilterer   // Log filterer for contract events
}

GnosisSafeMath is an auto generated Go binding around an Ethereum contract.

func DeployGnosisSafeMath 

func DeployGnosisSafeMath(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *GnosisSafeMath, error)

DeployGnosisSafeMath deploys a new Ethereum contract, binding an instance of GnosisSafeMath to it.

func NewGnosisSafeMath 

func NewGnosisSafeMath(address common.Address, backend bind.ContractBackend) (*GnosisSafeMath, error)

NewGnosisSafeMath creates a new instance of GnosisSafeMath, bound to a specific deployed contract.

type GnosisSafeMathCaller 

type GnosisSafeMathCaller struct {
	// contains filtered or unexported fields
}

GnosisSafeMathCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewGnosisSafeMathCaller 

func NewGnosisSafeMathCaller(address common.Address, caller bind.ContractCaller) (*GnosisSafeMathCaller, error)

NewGnosisSafeMathCaller creates a new read-only instance of GnosisSafeMath, bound to a specific deployed contract.

type GnosisSafeMathCallerRaw 

type GnosisSafeMathCallerRaw struct {
	Contract *GnosisSafeMathCaller // Generic read-only contract binding to access the raw methods on
}

GnosisSafeMathCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*GnosisSafeMathCallerRaw) Call 

func (_GnosisSafeMath *GnosisSafeMathCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type GnosisSafeMathCallerSession 

type GnosisSafeMathCallerSession struct {
	Contract *GnosisSafeMathCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts         // Call options to use throughout this session
}

GnosisSafeMathCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type GnosisSafeMathFilterer 

type GnosisSafeMathFilterer struct {
	// contains filtered or unexported fields
}

GnosisSafeMathFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewGnosisSafeMathFilterer 

func NewGnosisSafeMathFilterer(address common.Address, filterer bind.ContractFilterer) (*GnosisSafeMathFilterer, error)

NewGnosisSafeMathFilterer creates a new log filterer instance of GnosisSafeMath, bound to a specific deployed contract.

type GnosisSafeMathRaw 

type GnosisSafeMathRaw struct {
	Contract *GnosisSafeMath // Generic contract binding to access the raw methods on
}

GnosisSafeMathRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*GnosisSafeMathRaw) Call 

func (_GnosisSafeMath *GnosisSafeMathRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*GnosisSafeMathRaw) Transact 

func (_GnosisSafeMath *GnosisSafeMathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*GnosisSafeMathRaw) Transfer 

func (_GnosisSafeMath *GnosisSafeMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type GnosisSafeMathSession 

type GnosisSafeMathSession struct {
	Contract     *GnosisSafeMath   // 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
}

GnosisSafeMathSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type GnosisSafeMathTransactor 

type GnosisSafeMathTransactor struct {
	// contains filtered or unexported fields
}

GnosisSafeMathTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewGnosisSafeMathTransactor 

func NewGnosisSafeMathTransactor(address common.Address, transactor bind.ContractTransactor) (*GnosisSafeMathTransactor, error)

NewGnosisSafeMathTransactor creates a new write-only instance of GnosisSafeMath, bound to a specific deployed contract.

type GnosisSafeMathTransactorRaw 

type GnosisSafeMathTransactorRaw struct {
	Contract *GnosisSafeMathTransactor // Generic write-only contract binding to access the raw methods on
}

GnosisSafeMathTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*GnosisSafeMathTransactorRaw) Transact 

func (_GnosisSafeMath *GnosisSafeMathTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*GnosisSafeMathTransactorRaw) Transfer 

func (_GnosisSafeMath *GnosisSafeMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type GnosisSafeMathTransactorSession 

type GnosisSafeMathTransactorSession struct {
	Contract     *GnosisSafeMathTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
}

GnosisSafeMathTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type GnosisSafeRaw 

type GnosisSafeRaw struct {
	Contract *GnosisSafe // Generic contract binding to access the raw methods on
}

GnosisSafeRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*GnosisSafeRaw) Call 

func (_GnosisSafe *GnosisSafeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*GnosisSafeRaw) Transact 

func (_GnosisSafe *GnosisSafeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*GnosisSafeRaw) Transfer 

func (_GnosisSafe *GnosisSafeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type GnosisSafeRemovedOwner 

type GnosisSafeRemovedOwner struct {
	Owner common.Address
	Raw   types.Log // Blockchain specific contextual infos
}

GnosisSafeRemovedOwner represents a RemovedOwner event raised by the GnosisSafe contract.

type GnosisSafeRemovedOwnerIterator 

type GnosisSafeRemovedOwnerIterator struct {
	Event *GnosisSafeRemovedOwner // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

GnosisSafeRemovedOwnerIterator is returned from FilterRemovedOwner and is used to iterate over the raw logs and unpacked data for RemovedOwner events raised by the GnosisSafe contract.

func (*GnosisSafeRemovedOwnerIterator) Close 

func (it *GnosisSafeRemovedOwnerIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*GnosisSafeRemovedOwnerIterator) Error 

func (it *GnosisSafeRemovedOwnerIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*GnosisSafeRemovedOwnerIterator) Next 

func (it *GnosisSafeRemovedOwnerIterator) Next() bool

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.

type GnosisSafeSession 

type GnosisSafeSession struct {
	Contract     *GnosisSafe       // 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
}

GnosisSafeSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*GnosisSafeSession) AddOwnerWithThreshold 

func (_GnosisSafe *GnosisSafeSession) AddOwnerWithThreshold(owner common.Address, _threshold *big.Int) (*types.Transaction, error)

AddOwnerWithThreshold is a paid mutator transaction binding the contract method 0x0d582f13.

Solidity: function addOwnerWithThreshold(address owner, uint256 _threshold) returns()

func (*GnosisSafeSession) ApproveHash 

func (_GnosisSafe *GnosisSafeSession) ApproveHash(hashToApprove [32]byte) (*types.Transaction, error)

ApproveHash is a paid mutator transaction binding the contract method 0xd4d9bdcd.

Solidity: function approveHash(bytes32 hashToApprove) returns()

func (*GnosisSafeSession) ApprovedHashes 

func (_GnosisSafe *GnosisSafeSession) ApprovedHashes(arg0 common.Address, arg1 [32]byte) (*big.Int, error)

ApprovedHashes is a free data retrieval call binding the contract method 0x7d832974.

Solidity: function approvedHashes(address , bytes32 ) view returns(uint256)

func (*GnosisSafeSession) ChangeThreshold 

func (_GnosisSafe *GnosisSafeSession) ChangeThreshold(_threshold *big.Int) (*types.Transaction, error)

ChangeThreshold is a paid mutator transaction binding the contract method 0x694e80c3.

Solidity: function changeThreshold(uint256 _threshold) returns()

func (*GnosisSafeSession) CheckSignatures 

func (_GnosisSafe *GnosisSafeSession) CheckSignatures(dataHash [32]byte, data []byte, signatures []byte) (*types.Transaction, error)

CheckSignatures is a paid mutator transaction binding the contract method 0x934f3a11.

Solidity: function checkSignatures(bytes32 dataHash, bytes data, bytes signatures) returns()

func (*GnosisSafeSession) DisableModule 

func (_GnosisSafe *GnosisSafeSession) DisableModule(prevModule common.Address, module common.Address) (*types.Transaction, error)

DisableModule is a paid mutator transaction binding the contract method 0xe009cfde.

Solidity: function disableModule(address prevModule, address module) returns()

func (*GnosisSafeSession) DomainSeparator 

func (_GnosisSafe *GnosisSafeSession) DomainSeparator() ([32]byte, error)

DomainSeparator is a free data retrieval call binding the contract method 0xf698da25.

Solidity: function domainSeparator() view returns(bytes32)

func (*GnosisSafeSession) EnableModule 

func (_GnosisSafe *GnosisSafeSession) EnableModule(module common.Address) (*types.Transaction, error)

EnableModule is a paid mutator transaction binding the contract method 0x610b5925.

Solidity: function enableModule(address module) returns()

func (*GnosisSafeSession) EncodeTransactionData 

func (_GnosisSafe *GnosisSafeSession) EncodeTransactionData(to common.Address, value *big.Int, data []byte, operation uint8, safeTxGas *big.Int, baseGas *big.Int, gasPrice *big.Int, gasToken common.Address, refundReceiver common.Address, _nonce *big.Int) ([]byte, error)

EncodeTransactionData is a free data retrieval call binding the contract method 0xe86637db.

Solidity: function encodeTransactionData(address to, uint256 value, bytes data, uint8 operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address refundReceiver, uint256 _nonce) view returns(bytes)

func (*GnosisSafeSession) ExecTransaction 

func (_GnosisSafe *GnosisSafeSession) ExecTransaction(to common.Address, value *big.Int, data []byte, operation uint8, safeTxGas *big.Int, baseGas *big.Int, gasPrice *big.Int, gasToken common.Address, refundReceiver common.Address, signatures []byte) (*types.Transaction, error)

ExecTransaction is a paid mutator transaction binding the contract method 0x6a761202.

Solidity: function execTransaction(address to, uint256 value, bytes data, uint8 operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address refundReceiver, bytes signatures) payable returns(bool success)

func (*GnosisSafeSession) ExecTransactionFromModule 

func (_GnosisSafe *GnosisSafeSession) ExecTransactionFromModule(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

ExecTransactionFromModule is a paid mutator transaction binding the contract method 0x468721a7.

Solidity: function execTransactionFromModule(address to, uint256 value, bytes data, uint8 operation) returns(bool success)

func (*GnosisSafeSession) ExecTransactionFromModuleReturnData 

func (_GnosisSafe *GnosisSafeSession) ExecTransactionFromModuleReturnData(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

ExecTransactionFromModuleReturnData is a paid mutator transaction binding the contract method 0x5229073f.

Solidity: function execTransactionFromModuleReturnData(address to, uint256 value, bytes data, uint8 operation) returns(bool success, bytes returnData)

func (*GnosisSafeSession) Fallback 

func (_GnosisSafe *GnosisSafeSession) Fallback(calldata []byte) (*types.Transaction, error)

Fallback is a paid mutator transaction binding the contract fallback function.

Solidity: fallback() returns()

func (*GnosisSafeSession) GetChainId 

func (_GnosisSafe *GnosisSafeSession) GetChainId() (*big.Int, error)

GetChainId is a free data retrieval call binding the contract method 0x3408e470.

Solidity: function getChainId() view returns(uint256)

func (*GnosisSafeSession) GetMessageHash 

func (_GnosisSafe *GnosisSafeSession) GetMessageHash(message []byte) ([32]byte, error)

GetMessageHash is a free data retrieval call binding the contract method 0x0a1028c4.

Solidity: function getMessageHash(bytes message) view returns(bytes32)

func (*GnosisSafeSession) GetModulesPaginated 

func (_GnosisSafe *GnosisSafeSession) GetModulesPaginated(start common.Address, pageSize *big.Int) (struct {
	Array []common.Address
	Next  common.Address
}, error)

GetModulesPaginated is a free data retrieval call binding the contract method 0xcc2f8452.

Solidity: function getModulesPaginated(address start, uint256 pageSize) view returns(address[] array, address next)

func (*GnosisSafeSession) GetOwners 

func (_GnosisSafe *GnosisSafeSession) GetOwners() ([]common.Address, error)

GetOwners is a free data retrieval call binding the contract method 0xa0e67e2b.

Solidity: function getOwners() view returns(address[])

func (*GnosisSafeSession) GetSelfBalance 

func (_GnosisSafe *GnosisSafeSession) GetSelfBalance() (*big.Int, error)

GetSelfBalance is a free data retrieval call binding the contract method 0x048a5fed.

Solidity: function getSelfBalance() view returns(uint256)

func (*GnosisSafeSession) GetStorageAt 

func (_GnosisSafe *GnosisSafeSession) GetStorageAt(offset *big.Int, length *big.Int) ([]byte, error)

GetStorageAt is a free data retrieval call binding the contract method 0x5624b25b.

Solidity: function getStorageAt(uint256 offset, uint256 length) view returns(bytes)

func (*GnosisSafeSession) GetThreshold 

func (_GnosisSafe *GnosisSafeSession) GetThreshold() (*big.Int, error)

GetThreshold is a free data retrieval call binding the contract method 0xe75235b8.

Solidity: function getThreshold() view returns(uint256)

func (*GnosisSafeSession) GetTransactionHash 

func (_GnosisSafe *GnosisSafeSession) GetTransactionHash(to common.Address, value *big.Int, data []byte, operation uint8, safeTxGas *big.Int, baseGas *big.Int, gasPrice *big.Int, gasToken common.Address, refundReceiver common.Address, _nonce *big.Int) ([32]byte, error)

GetTransactionHash is a free data retrieval call binding the contract method 0xd8d11f78.

Solidity: function getTransactionHash(address to, uint256 value, bytes data, uint8 operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address refundReceiver, uint256 _nonce) view returns(bytes32)

func (*GnosisSafeSession) IsModuleEnabled 

func (_GnosisSafe *GnosisSafeSession) IsModuleEnabled(module common.Address) (bool, error)

IsModuleEnabled is a free data retrieval call binding the contract method 0x2d9ad53d.

Solidity: function isModuleEnabled(address module) view returns(bool)

func (*GnosisSafeSession) IsOwner 

func (_GnosisSafe *GnosisSafeSession) IsOwner(owner common.Address) (bool, error)

IsOwner is a free data retrieval call binding the contract method 0x2f54bf6e.

Solidity: function isOwner(address owner) view returns(bool)

func (*GnosisSafeSession) NAME 

func (_GnosisSafe *GnosisSafeSession) NAME() (string, error)

NAME is a free data retrieval call binding the contract method 0xa3f4df7e.

Solidity: function NAME() view returns(string)

func (*GnosisSafeSession) Nonce 

func (_GnosisSafe *GnosisSafeSession) Nonce() (*big.Int, error)

Nonce is a free data retrieval call binding the contract method 0xaffed0e0.

Solidity: function nonce() view returns(uint256)

func (*GnosisSafeSession) Receive 

func (_GnosisSafe *GnosisSafeSession) Receive() (*types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

func (*GnosisSafeSession) RemoveOwner 

func (_GnosisSafe *GnosisSafeSession) RemoveOwner(prevOwner common.Address, owner common.Address, _threshold *big.Int) (*types.Transaction, error)

RemoveOwner is a paid mutator transaction binding the contract method 0xf8dc5dd9.

Solidity: function removeOwner(address prevOwner, address owner, uint256 _threshold) returns()

func (*GnosisSafeSession) RequiredTxGas 

func (_GnosisSafe *GnosisSafeSession) RequiredTxGas(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

RequiredTxGas is a paid mutator transaction binding the contract method 0xc4ca3a9c.

Solidity: function requiredTxGas(address to, uint256 value, bytes data, uint8 operation) returns(uint256)

func (*GnosisSafeSession) SetFallbackHandler 

func (_GnosisSafe *GnosisSafeSession) SetFallbackHandler(handler common.Address) (*types.Transaction, error)

SetFallbackHandler is a paid mutator transaction binding the contract method 0xf08a0323.

Solidity: function setFallbackHandler(address handler) returns()

func (*GnosisSafeSession) Setup 

func (_GnosisSafe *GnosisSafeSession) Setup(_owners []common.Address, _threshold *big.Int, to common.Address, data []byte, fallbackHandler common.Address, paymentToken common.Address, payment *big.Int, paymentReceiver common.Address) (*types.Transaction, error)

Setup is a paid mutator transaction binding the contract method 0xb63e800d.

Solidity: function setup(address[] _owners, uint256 _threshold, address to, bytes data, address fallbackHandler, address paymentToken, uint256 payment, address paymentReceiver) returns()

func (*GnosisSafeSession) SignMessage 

func (_GnosisSafe *GnosisSafeSession) SignMessage(_data []byte) (*types.Transaction, error)

SignMessage is a paid mutator transaction binding the contract method 0x85a5affe.

Solidity: function signMessage(bytes _data) returns()

func (*GnosisSafeSession) SignedMessages 

func (_GnosisSafe *GnosisSafeSession) SignedMessages(arg0 [32]byte) (*big.Int, error)

SignedMessages is a free data retrieval call binding the contract method 0x5ae6bd37.

Solidity: function signedMessages(bytes32 ) view returns(uint256)

func (*GnosisSafeSession) SimulateDelegatecall 

func (_GnosisSafe *GnosisSafeSession) SimulateDelegatecall(targetContract common.Address, calldataPayload []byte) (*types.Transaction, error)

SimulateDelegatecall is a paid mutator transaction binding the contract method 0xf84436bd.

Solidity: function simulateDelegatecall(address targetContract, bytes calldataPayload) returns(bytes)

func (*GnosisSafeSession) SimulateDelegatecallInternal 

func (_GnosisSafe *GnosisSafeSession) SimulateDelegatecallInternal(targetContract common.Address, calldataPayload []byte) (*types.Transaction, error)

SimulateDelegatecallInternal is a paid mutator transaction binding the contract method 0x43218e19.

Solidity: function simulateDelegatecallInternal(address targetContract, bytes calldataPayload) returns(bytes)

func (*GnosisSafeSession) SwapOwner 

func (_GnosisSafe *GnosisSafeSession) SwapOwner(prevOwner common.Address, oldOwner common.Address, newOwner common.Address) (*types.Transaction, error)

SwapOwner is a paid mutator transaction binding the contract method 0xe318b52b.

Solidity: function swapOwner(address prevOwner, address oldOwner, address newOwner) returns()

func (*GnosisSafeSession) VERSION 

func (_GnosisSafe *GnosisSafeSession) VERSION() (string, error)

VERSION is a free data retrieval call binding the contract method 0xffa1ad74.

Solidity: function VERSION() view returns(string)

type GnosisSafeSignMsg 

type GnosisSafeSignMsg struct {
	MsgHash [32]byte
	Raw     types.Log // Blockchain specific contextual infos
}

GnosisSafeSignMsg represents a SignMsg event raised by the GnosisSafe contract.

type GnosisSafeSignMsgIterator 

type GnosisSafeSignMsgIterator struct {
	Event *GnosisSafeSignMsg // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

GnosisSafeSignMsgIterator is returned from FilterSignMsg and is used to iterate over the raw logs and unpacked data for SignMsg events raised by the GnosisSafe contract.

func (*GnosisSafeSignMsgIterator) Close 

func (it *GnosisSafeSignMsgIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*GnosisSafeSignMsgIterator) Error 

func (it *GnosisSafeSignMsgIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*GnosisSafeSignMsgIterator) Next 

func (it *GnosisSafeSignMsgIterator) Next() bool

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.

type GnosisSafeSignatureRecover 

type GnosisSafeSignatureRecover struct {
	Index *big.Int
	Owner common.Address
	Hash  [32]byte
	Raw   types.Log // Blockchain specific contextual infos
}

GnosisSafeSignatureRecover represents a SignatureRecover event raised by the GnosisSafe contract.

type GnosisSafeSignatureRecoverIterator 

type GnosisSafeSignatureRecoverIterator struct {
	Event *GnosisSafeSignatureRecover // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

GnosisSafeSignatureRecoverIterator is returned from FilterSignatureRecover and is used to iterate over the raw logs and unpacked data for SignatureRecover events raised by the GnosisSafe contract.

func (*GnosisSafeSignatureRecoverIterator) Close 

func (it *GnosisSafeSignatureRecoverIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*GnosisSafeSignatureRecoverIterator) Error 

func (it *GnosisSafeSignatureRecoverIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*GnosisSafeSignatureRecoverIterator) Next 

func (it *GnosisSafeSignatureRecoverIterator) Next() bool

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.

type GnosisSafeTransactor 

type GnosisSafeTransactor struct {
	// contains filtered or unexported fields
}

GnosisSafeTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewGnosisSafeTransactor 

func NewGnosisSafeTransactor(address common.Address, transactor bind.ContractTransactor) (*GnosisSafeTransactor, error)

NewGnosisSafeTransactor creates a new write-only instance of GnosisSafe, bound to a specific deployed contract.

func (*GnosisSafeTransactor) AddOwnerWithThreshold 

func (_GnosisSafe *GnosisSafeTransactor) AddOwnerWithThreshold(opts *bind.TransactOpts, owner common.Address, _threshold *big.Int) (*types.Transaction, error)

AddOwnerWithThreshold is a paid mutator transaction binding the contract method 0x0d582f13.

Solidity: function addOwnerWithThreshold(address owner, uint256 _threshold) returns()

func (*GnosisSafeTransactor) ApproveHash 

func (_GnosisSafe *GnosisSafeTransactor) ApproveHash(opts *bind.TransactOpts, hashToApprove [32]byte) (*types.Transaction, error)

ApproveHash is a paid mutator transaction binding the contract method 0xd4d9bdcd.

Solidity: function approveHash(bytes32 hashToApprove) returns()

func (*GnosisSafeTransactor) ChangeThreshold 

func (_GnosisSafe *GnosisSafeTransactor) ChangeThreshold(opts *bind.TransactOpts, _threshold *big.Int) (*types.Transaction, error)

ChangeThreshold is a paid mutator transaction binding the contract method 0x694e80c3.

Solidity: function changeThreshold(uint256 _threshold) returns()

func (*GnosisSafeTransactor) CheckSignatures 

func (_GnosisSafe *GnosisSafeTransactor) CheckSignatures(opts *bind.TransactOpts, dataHash [32]byte, data []byte, signatures []byte) (*types.Transaction, error)

CheckSignatures is a paid mutator transaction binding the contract method 0x934f3a11.

Solidity: function checkSignatures(bytes32 dataHash, bytes data, bytes signatures) returns()

func (*GnosisSafeTransactor) DisableModule 

func (_GnosisSafe *GnosisSafeTransactor) DisableModule(opts *bind.TransactOpts, prevModule common.Address, module common.Address) (*types.Transaction, error)

DisableModule is a paid mutator transaction binding the contract method 0xe009cfde.

Solidity: function disableModule(address prevModule, address module) returns()

func (*GnosisSafeTransactor) EnableModule 

func (_GnosisSafe *GnosisSafeTransactor) EnableModule(opts *bind.TransactOpts, module common.Address) (*types.Transaction, error)

EnableModule is a paid mutator transaction binding the contract method 0x610b5925.

Solidity: function enableModule(address module) returns()

func (*GnosisSafeTransactor) ExecTransaction 

func (_GnosisSafe *GnosisSafeTransactor) ExecTransaction(opts *bind.TransactOpts, to common.Address, value *big.Int, data []byte, operation uint8, safeTxGas *big.Int, baseGas *big.Int, gasPrice *big.Int, gasToken common.Address, refundReceiver common.Address, signatures []byte) (*types.Transaction, error)

ExecTransaction is a paid mutator transaction binding the contract method 0x6a761202.

Solidity: function execTransaction(address to, uint256 value, bytes data, uint8 operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address refundReceiver, bytes signatures) payable returns(bool success)

func (*GnosisSafeTransactor) ExecTransactionFromModule 

func (_GnosisSafe *GnosisSafeTransactor) ExecTransactionFromModule(opts *bind.TransactOpts, to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

ExecTransactionFromModule is a paid mutator transaction binding the contract method 0x468721a7.

Solidity: function execTransactionFromModule(address to, uint256 value, bytes data, uint8 operation) returns(bool success)

func (*GnosisSafeTransactor) ExecTransactionFromModuleReturnData 

func (_GnosisSafe *GnosisSafeTransactor) ExecTransactionFromModuleReturnData(opts *bind.TransactOpts, to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

ExecTransactionFromModuleReturnData is a paid mutator transaction binding the contract method 0x5229073f.

Solidity: function execTransactionFromModuleReturnData(address to, uint256 value, bytes data, uint8 operation) returns(bool success, bytes returnData)

func (*GnosisSafeTransactor) Fallback 

func (_GnosisSafe *GnosisSafeTransactor) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error)

Fallback is a paid mutator transaction binding the contract fallback function.

Solidity: fallback() returns()

func (*GnosisSafeTransactor) Receive 

func (_GnosisSafe *GnosisSafeTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

func (*GnosisSafeTransactor) RemoveOwner 

func (_GnosisSafe *GnosisSafeTransactor) RemoveOwner(opts *bind.TransactOpts, prevOwner common.Address, owner common.Address, _threshold *big.Int) (*types.Transaction, error)

RemoveOwner is a paid mutator transaction binding the contract method 0xf8dc5dd9.

Solidity: function removeOwner(address prevOwner, address owner, uint256 _threshold) returns()

func (*GnosisSafeTransactor) RequiredTxGas 

func (_GnosisSafe *GnosisSafeTransactor) RequiredTxGas(opts *bind.TransactOpts, to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

RequiredTxGas is a paid mutator transaction binding the contract method 0xc4ca3a9c.

Solidity: function requiredTxGas(address to, uint256 value, bytes data, uint8 operation) returns(uint256)

func (*GnosisSafeTransactor) SetFallbackHandler 

func (_GnosisSafe *GnosisSafeTransactor) SetFallbackHandler(opts *bind.TransactOpts, handler common.Address) (*types.Transaction, error)

SetFallbackHandler is a paid mutator transaction binding the contract method 0xf08a0323.

Solidity: function setFallbackHandler(address handler) returns()

func (*GnosisSafeTransactor) Setup 

func (_GnosisSafe *GnosisSafeTransactor) Setup(opts *bind.TransactOpts, _owners []common.Address, _threshold *big.Int, to common.Address, data []byte, fallbackHandler common.Address, paymentToken common.Address, payment *big.Int, paymentReceiver common.Address) (*types.Transaction, error)

Setup is a paid mutator transaction binding the contract method 0xb63e800d.

Solidity: function setup(address[] _owners, uint256 _threshold, address to, bytes data, address fallbackHandler, address paymentToken, uint256 payment, address paymentReceiver) returns()

func (*GnosisSafeTransactor) SignMessage 

func (_GnosisSafe *GnosisSafeTransactor) SignMessage(opts *bind.TransactOpts, _data []byte) (*types.Transaction, error)

SignMessage is a paid mutator transaction binding the contract method 0x85a5affe.

Solidity: function signMessage(bytes _data) returns()

func (*GnosisSafeTransactor) SimulateDelegatecall 

func (_GnosisSafe *GnosisSafeTransactor) SimulateDelegatecall(opts *bind.TransactOpts, targetContract common.Address, calldataPayload []byte) (*types.Transaction, error)

SimulateDelegatecall is a paid mutator transaction binding the contract method 0xf84436bd.

Solidity: function simulateDelegatecall(address targetContract, bytes calldataPayload) returns(bytes)

func (*GnosisSafeTransactor) SimulateDelegatecallInternal 

func (_GnosisSafe *GnosisSafeTransactor) SimulateDelegatecallInternal(opts *bind.TransactOpts, targetContract common.Address, calldataPayload []byte) (*types.Transaction, error)

SimulateDelegatecallInternal is a paid mutator transaction binding the contract method 0x43218e19.

Solidity: function simulateDelegatecallInternal(address targetContract, bytes calldataPayload) returns(bytes)

func (*GnosisSafeTransactor) SwapOwner 

func (_GnosisSafe *GnosisSafeTransactor) SwapOwner(opts *bind.TransactOpts, prevOwner common.Address, oldOwner common.Address, newOwner common.Address) (*types.Transaction, error)

SwapOwner is a paid mutator transaction binding the contract method 0xe318b52b.

Solidity: function swapOwner(address prevOwner, address oldOwner, address newOwner) returns()

type GnosisSafeTransactorRaw 

type GnosisSafeTransactorRaw struct {
	Contract *GnosisSafeTransactor // Generic write-only contract binding to access the raw methods on
}

GnosisSafeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*GnosisSafeTransactorRaw) Transact 

func (_GnosisSafe *GnosisSafeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*GnosisSafeTransactorRaw) Transfer 

func (_GnosisSafe *GnosisSafeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type GnosisSafeTransactorSession 

type GnosisSafeTransactorSession struct {
	Contract     *GnosisSafeTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts     // Transaction auth options to use throughout this session
}

GnosisSafeTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*GnosisSafeTransactorSession) AddOwnerWithThreshold 

func (_GnosisSafe *GnosisSafeTransactorSession) AddOwnerWithThreshold(owner common.Address, _threshold *big.Int) (*types.Transaction, error)

AddOwnerWithThreshold is a paid mutator transaction binding the contract method 0x0d582f13.

Solidity: function addOwnerWithThreshold(address owner, uint256 _threshold) returns()

func (*GnosisSafeTransactorSession) ApproveHash 

func (_GnosisSafe *GnosisSafeTransactorSession) ApproveHash(hashToApprove [32]byte) (*types.Transaction, error)

ApproveHash is a paid mutator transaction binding the contract method 0xd4d9bdcd.

Solidity: function approveHash(bytes32 hashToApprove) returns()

func (*GnosisSafeTransactorSession) ChangeThreshold 

func (_GnosisSafe *GnosisSafeTransactorSession) ChangeThreshold(_threshold *big.Int) (*types.Transaction, error)

ChangeThreshold is a paid mutator transaction binding the contract method 0x694e80c3.

Solidity: function changeThreshold(uint256 _threshold) returns()

func (*GnosisSafeTransactorSession) CheckSignatures 

func (_GnosisSafe *GnosisSafeTransactorSession) CheckSignatures(dataHash [32]byte, data []byte, signatures []byte) (*types.Transaction, error)

CheckSignatures is a paid mutator transaction binding the contract method 0x934f3a11.

Solidity: function checkSignatures(bytes32 dataHash, bytes data, bytes signatures) returns()

func (*GnosisSafeTransactorSession) DisableModule 

func (_GnosisSafe *GnosisSafeTransactorSession) DisableModule(prevModule common.Address, module common.Address) (*types.Transaction, error)

DisableModule is a paid mutator transaction binding the contract method 0xe009cfde.

Solidity: function disableModule(address prevModule, address module) returns()

func (*GnosisSafeTransactorSession) EnableModule 

func (_GnosisSafe *GnosisSafeTransactorSession) EnableModule(module common.Address) (*types.Transaction, error)

EnableModule is a paid mutator transaction binding the contract method 0x610b5925.

Solidity: function enableModule(address module) returns()

func (*GnosisSafeTransactorSession) ExecTransaction 

func (_GnosisSafe *GnosisSafeTransactorSession) ExecTransaction(to common.Address, value *big.Int, data []byte, operation uint8, safeTxGas *big.Int, baseGas *big.Int, gasPrice *big.Int, gasToken common.Address, refundReceiver common.Address, signatures []byte) (*types.Transaction, error)

ExecTransaction is a paid mutator transaction binding the contract method 0x6a761202.

Solidity: function execTransaction(address to, uint256 value, bytes data, uint8 operation, uint256 safeTxGas, uint256 baseGas, uint256 gasPrice, address gasToken, address refundReceiver, bytes signatures) payable returns(bool success)

func (*GnosisSafeTransactorSession) ExecTransactionFromModule 

func (_GnosisSafe *GnosisSafeTransactorSession) ExecTransactionFromModule(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

ExecTransactionFromModule is a paid mutator transaction binding the contract method 0x468721a7.

Solidity: function execTransactionFromModule(address to, uint256 value, bytes data, uint8 operation) returns(bool success)

func (*GnosisSafeTransactorSession) ExecTransactionFromModuleReturnData 

func (_GnosisSafe *GnosisSafeTransactorSession) ExecTransactionFromModuleReturnData(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

ExecTransactionFromModuleReturnData is a paid mutator transaction binding the contract method 0x5229073f.

Solidity: function execTransactionFromModuleReturnData(address to, uint256 value, bytes data, uint8 operation) returns(bool success, bytes returnData)

func (*GnosisSafeTransactorSession) Fallback 

func (_GnosisSafe *GnosisSafeTransactorSession) Fallback(calldata []byte) (*types.Transaction, error)

Fallback is a paid mutator transaction binding the contract fallback function.

Solidity: fallback() returns()

func (*GnosisSafeTransactorSession) Receive 

func (_GnosisSafe *GnosisSafeTransactorSession) Receive() (*types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

func (*GnosisSafeTransactorSession) RemoveOwner 

func (_GnosisSafe *GnosisSafeTransactorSession) RemoveOwner(prevOwner common.Address, owner common.Address, _threshold *big.Int) (*types.Transaction, error)

RemoveOwner is a paid mutator transaction binding the contract method 0xf8dc5dd9.

Solidity: function removeOwner(address prevOwner, address owner, uint256 _threshold) returns()

func (*GnosisSafeTransactorSession) RequiredTxGas 

func (_GnosisSafe *GnosisSafeTransactorSession) RequiredTxGas(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

RequiredTxGas is a paid mutator transaction binding the contract method 0xc4ca3a9c.

Solidity: function requiredTxGas(address to, uint256 value, bytes data, uint8 operation) returns(uint256)

func (*GnosisSafeTransactorSession) SetFallbackHandler 

func (_GnosisSafe *GnosisSafeTransactorSession) SetFallbackHandler(handler common.Address) (*types.Transaction, error)

SetFallbackHandler is a paid mutator transaction binding the contract method 0xf08a0323.

Solidity: function setFallbackHandler(address handler) returns()

func (*GnosisSafeTransactorSession) Setup 

func (_GnosisSafe *GnosisSafeTransactorSession) Setup(_owners []common.Address, _threshold *big.Int, to common.Address, data []byte, fallbackHandler common.Address, paymentToken common.Address, payment *big.Int, paymentReceiver common.Address) (*types.Transaction, error)

Setup is a paid mutator transaction binding the contract method 0xb63e800d.

Solidity: function setup(address[] _owners, uint256 _threshold, address to, bytes data, address fallbackHandler, address paymentToken, uint256 payment, address paymentReceiver) returns()

func (*GnosisSafeTransactorSession) SignMessage 

func (_GnosisSafe *GnosisSafeTransactorSession) SignMessage(_data []byte) (*types.Transaction, error)

SignMessage is a paid mutator transaction binding the contract method 0x85a5affe.

Solidity: function signMessage(bytes _data) returns()

func (*GnosisSafeTransactorSession) SimulateDelegatecall 

func (_GnosisSafe *GnosisSafeTransactorSession) SimulateDelegatecall(targetContract common.Address, calldataPayload []byte) (*types.Transaction, error)

SimulateDelegatecall is a paid mutator transaction binding the contract method 0xf84436bd.

Solidity: function simulateDelegatecall(address targetContract, bytes calldataPayload) returns(bytes)

func (*GnosisSafeTransactorSession) SimulateDelegatecallInternal 

func (_GnosisSafe *GnosisSafeTransactorSession) SimulateDelegatecallInternal(targetContract common.Address, calldataPayload []byte) (*types.Transaction, error)

SimulateDelegatecallInternal is a paid mutator transaction binding the contract method 0x43218e19.

Solidity: function simulateDelegatecallInternal(address targetContract, bytes calldataPayload) returns(bytes)

func (*GnosisSafeTransactorSession) SwapOwner 

func (_GnosisSafe *GnosisSafeTransactorSession) SwapOwner(prevOwner common.Address, oldOwner common.Address, newOwner common.Address) (*types.Transaction, error)

SwapOwner is a paid mutator transaction binding the contract method 0xe318b52b.

Solidity: function swapOwner(address prevOwner, address oldOwner, address newOwner) returns()

type ISignatureValidator 

type ISignatureValidator struct {
	ISignatureValidatorCaller     // Read-only binding to the contract
	ISignatureValidatorTransactor // Write-only binding to the contract
	ISignatureValidatorFilterer   // Log filterer for contract events
}

ISignatureValidator is an auto generated Go binding around an Ethereum contract.

func NewISignatureValidator 

func NewISignatureValidator(address common.Address, backend bind.ContractBackend) (*ISignatureValidator, error)

NewISignatureValidator creates a new instance of ISignatureValidator, bound to a specific deployed contract.

type ISignatureValidatorCaller 

type ISignatureValidatorCaller struct {
	// contains filtered or unexported fields
}

ISignatureValidatorCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewISignatureValidatorCaller 

func NewISignatureValidatorCaller(address common.Address, caller bind.ContractCaller) (*ISignatureValidatorCaller, error)

NewISignatureValidatorCaller creates a new read-only instance of ISignatureValidator, bound to a specific deployed contract.

func (*ISignatureValidatorCaller) IsValidSignature 

func (_ISignatureValidator *ISignatureValidatorCaller) IsValidSignature(opts *bind.CallOpts, _data []byte, _signature []byte) ([4]byte, error)

IsValidSignature is a free data retrieval call binding the contract method 0x20c13b0b.

Solidity: function isValidSignature(bytes _data, bytes _signature) view returns(bytes4)

type ISignatureValidatorCallerRaw 

type ISignatureValidatorCallerRaw struct {
	Contract *ISignatureValidatorCaller // Generic read-only contract binding to access the raw methods on
}

ISignatureValidatorCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*ISignatureValidatorCallerRaw) Call 

func (_ISignatureValidator *ISignatureValidatorCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type ISignatureValidatorCallerSession 

type ISignatureValidatorCallerSession struct {
	Contract *ISignatureValidatorCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts              // Call options to use throughout this session
}

ISignatureValidatorCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*ISignatureValidatorCallerSession) IsValidSignature 

func (_ISignatureValidator *ISignatureValidatorCallerSession) IsValidSignature(_data []byte, _signature []byte) ([4]byte, error)

IsValidSignature is a free data retrieval call binding the contract method 0x20c13b0b.

Solidity: function isValidSignature(bytes _data, bytes _signature) view returns(bytes4)

type ISignatureValidatorConstants 

type ISignatureValidatorConstants struct {
	ISignatureValidatorConstantsCaller     // Read-only binding to the contract
	ISignatureValidatorConstantsTransactor // Write-only binding to the contract
	ISignatureValidatorConstantsFilterer   // Log filterer for contract events
}

ISignatureValidatorConstants is an auto generated Go binding around an Ethereum contract.

func DeployISignatureValidatorConstants 

func DeployISignatureValidatorConstants(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ISignatureValidatorConstants, error)

DeployISignatureValidatorConstants deploys a new Ethereum contract, binding an instance of ISignatureValidatorConstants to it.

func NewISignatureValidatorConstants 

func NewISignatureValidatorConstants(address common.Address, backend bind.ContractBackend) (*ISignatureValidatorConstants, error)

NewISignatureValidatorConstants creates a new instance of ISignatureValidatorConstants, bound to a specific deployed contract.

type ISignatureValidatorConstantsCaller 

type ISignatureValidatorConstantsCaller struct {
	// contains filtered or unexported fields
}

ISignatureValidatorConstantsCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewISignatureValidatorConstantsCaller 

func NewISignatureValidatorConstantsCaller(address common.Address, caller bind.ContractCaller) (*ISignatureValidatorConstantsCaller, error)

NewISignatureValidatorConstantsCaller creates a new read-only instance of ISignatureValidatorConstants, bound to a specific deployed contract.

type ISignatureValidatorConstantsCallerRaw 

type ISignatureValidatorConstantsCallerRaw struct {
	Contract *ISignatureValidatorConstantsCaller // Generic read-only contract binding to access the raw methods on
}

ISignatureValidatorConstantsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*ISignatureValidatorConstantsCallerRaw) Call 

func (_ISignatureValidatorConstants *ISignatureValidatorConstantsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type ISignatureValidatorConstantsCallerSession 

type ISignatureValidatorConstantsCallerSession struct {
	Contract *ISignatureValidatorConstantsCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts                       // Call options to use throughout this session
}

ISignatureValidatorConstantsCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type ISignatureValidatorConstantsFilterer 

type ISignatureValidatorConstantsFilterer struct {
	// contains filtered or unexported fields
}

ISignatureValidatorConstantsFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewISignatureValidatorConstantsFilterer 

func NewISignatureValidatorConstantsFilterer(address common.Address, filterer bind.ContractFilterer) (*ISignatureValidatorConstantsFilterer, error)

NewISignatureValidatorConstantsFilterer creates a new log filterer instance of ISignatureValidatorConstants, bound to a specific deployed contract.

type ISignatureValidatorConstantsRaw 

type ISignatureValidatorConstantsRaw struct {
	Contract *ISignatureValidatorConstants // Generic contract binding to access the raw methods on
}

ISignatureValidatorConstantsRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*ISignatureValidatorConstantsRaw) Call 

func (_ISignatureValidatorConstants *ISignatureValidatorConstantsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*ISignatureValidatorConstantsRaw) Transact 

func (_ISignatureValidatorConstants *ISignatureValidatorConstantsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ISignatureValidatorConstantsRaw) Transfer 

func (_ISignatureValidatorConstants *ISignatureValidatorConstantsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ISignatureValidatorConstantsSession 

type ISignatureValidatorConstantsSession struct {
	Contract     *ISignatureValidatorConstants // 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
}

ISignatureValidatorConstantsSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type ISignatureValidatorConstantsTransactor 

type ISignatureValidatorConstantsTransactor struct {
	// contains filtered or unexported fields
}

ISignatureValidatorConstantsTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewISignatureValidatorConstantsTransactor 

func NewISignatureValidatorConstantsTransactor(address common.Address, transactor bind.ContractTransactor) (*ISignatureValidatorConstantsTransactor, error)

NewISignatureValidatorConstantsTransactor creates a new write-only instance of ISignatureValidatorConstants, bound to a specific deployed contract.

type ISignatureValidatorConstantsTransactorRaw 

type ISignatureValidatorConstantsTransactorRaw struct {
	Contract *ISignatureValidatorConstantsTransactor // Generic write-only contract binding to access the raw methods on
}

ISignatureValidatorConstantsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*ISignatureValidatorConstantsTransactorRaw) Transact 

func (_ISignatureValidatorConstants *ISignatureValidatorConstantsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ISignatureValidatorConstantsTransactorRaw) Transfer 

func (_ISignatureValidatorConstants *ISignatureValidatorConstantsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ISignatureValidatorConstantsTransactorSession 

type ISignatureValidatorConstantsTransactorSession struct {
	Contract     *ISignatureValidatorConstantsTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts                       // Transaction auth options to use throughout this session
}

ISignatureValidatorConstantsTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type ISignatureValidatorFilterer 

type ISignatureValidatorFilterer struct {
	// contains filtered or unexported fields
}

ISignatureValidatorFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewISignatureValidatorFilterer 

func NewISignatureValidatorFilterer(address common.Address, filterer bind.ContractFilterer) (*ISignatureValidatorFilterer, error)

NewISignatureValidatorFilterer creates a new log filterer instance of ISignatureValidator, bound to a specific deployed contract.

type ISignatureValidatorRaw 

type ISignatureValidatorRaw struct {
	Contract *ISignatureValidator // Generic contract binding to access the raw methods on
}

ISignatureValidatorRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*ISignatureValidatorRaw) Call 

func (_ISignatureValidator *ISignatureValidatorRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*ISignatureValidatorRaw) Transact 

func (_ISignatureValidator *ISignatureValidatorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ISignatureValidatorRaw) Transfer 

func (_ISignatureValidator *ISignatureValidatorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ISignatureValidatorSession 

type ISignatureValidatorSession struct {
	Contract     *ISignatureValidator // 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
}

ISignatureValidatorSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*ISignatureValidatorSession) IsValidSignature 

func (_ISignatureValidator *ISignatureValidatorSession) IsValidSignature(_data []byte, _signature []byte) ([4]byte, error)

IsValidSignature is a free data retrieval call binding the contract method 0x20c13b0b.

Solidity: function isValidSignature(bytes _data, bytes _signature) view returns(bytes4)

type ISignatureValidatorTransactor 

type ISignatureValidatorTransactor struct {
	// contains filtered or unexported fields
}

ISignatureValidatorTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewISignatureValidatorTransactor 

func NewISignatureValidatorTransactor(address common.Address, transactor bind.ContractTransactor) (*ISignatureValidatorTransactor, error)

NewISignatureValidatorTransactor creates a new write-only instance of ISignatureValidator, bound to a specific deployed contract.

type ISignatureValidatorTransactorRaw 

type ISignatureValidatorTransactorRaw struct {
	Contract *ISignatureValidatorTransactor // Generic write-only contract binding to access the raw methods on
}

ISignatureValidatorTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*ISignatureValidatorTransactorRaw) Transact 

func (_ISignatureValidator *ISignatureValidatorTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ISignatureValidatorTransactorRaw) Transfer 

func (_ISignatureValidator *ISignatureValidatorTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ISignatureValidatorTransactorSession 

type ISignatureValidatorTransactorSession struct {
	Contract     *ISignatureValidatorTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts              // Transaction auth options to use throughout this session
}

ISignatureValidatorTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type ModuleManager 

type ModuleManager struct {
	ModuleManagerCaller     // Read-only binding to the contract
	ModuleManagerTransactor // Write-only binding to the contract
	ModuleManagerFilterer   // Log filterer for contract events
}

ModuleManager is an auto generated Go binding around an Ethereum contract.

func DeployModuleManager 

func DeployModuleManager(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ModuleManager, error)

DeployModuleManager deploys a new Ethereum contract, binding an instance of ModuleManager to it.

func NewModuleManager 

func NewModuleManager(address common.Address, backend bind.ContractBackend) (*ModuleManager, error)

NewModuleManager creates a new instance of ModuleManager, bound to a specific deployed contract.

type ModuleManagerCaller 

type ModuleManagerCaller struct {
	// contains filtered or unexported fields
}

ModuleManagerCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewModuleManagerCaller 

func NewModuleManagerCaller(address common.Address, caller bind.ContractCaller) (*ModuleManagerCaller, error)

NewModuleManagerCaller creates a new read-only instance of ModuleManager, bound to a specific deployed contract.

func (*ModuleManagerCaller) GetModulesPaginated 

func (_ModuleManager *ModuleManagerCaller) GetModulesPaginated(opts *bind.CallOpts, start common.Address, pageSize *big.Int) (struct {
	Array []common.Address
	Next  common.Address
}, error)

GetModulesPaginated is a free data retrieval call binding the contract method 0xcc2f8452.

Solidity: function getModulesPaginated(address start, uint256 pageSize) view returns(address[] array, address next)

func (*ModuleManagerCaller) IsModuleEnabled 

func (_ModuleManager *ModuleManagerCaller) IsModuleEnabled(opts *bind.CallOpts, module common.Address) (bool, error)

IsModuleEnabled is a free data retrieval call binding the contract method 0x2d9ad53d.

Solidity: function isModuleEnabled(address module) view returns(bool)

type ModuleManagerCallerRaw 

type ModuleManagerCallerRaw struct {
	Contract *ModuleManagerCaller // Generic read-only contract binding to access the raw methods on
}

ModuleManagerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*ModuleManagerCallerRaw) Call 

func (_ModuleManager *ModuleManagerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type ModuleManagerCallerSession 

type ModuleManagerCallerSession struct {
	Contract *ModuleManagerCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts        // Call options to use throughout this session
}

ModuleManagerCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*ModuleManagerCallerSession) GetModulesPaginated 

func (_ModuleManager *ModuleManagerCallerSession) GetModulesPaginated(start common.Address, pageSize *big.Int) (struct {
	Array []common.Address
	Next  common.Address
}, error)

GetModulesPaginated is a free data retrieval call binding the contract method 0xcc2f8452.

Solidity: function getModulesPaginated(address start, uint256 pageSize) view returns(address[] array, address next)

func (*ModuleManagerCallerSession) IsModuleEnabled 

func (_ModuleManager *ModuleManagerCallerSession) IsModuleEnabled(module common.Address) (bool, error)

IsModuleEnabled is a free data retrieval call binding the contract method 0x2d9ad53d.

Solidity: function isModuleEnabled(address module) view returns(bool)

type ModuleManagerDisabledModule 

type ModuleManagerDisabledModule struct {
	Module common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

ModuleManagerDisabledModule represents a DisabledModule event raised by the ModuleManager contract.

type ModuleManagerDisabledModuleIterator 

type ModuleManagerDisabledModuleIterator struct {
	Event *ModuleManagerDisabledModule // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

ModuleManagerDisabledModuleIterator is returned from FilterDisabledModule and is used to iterate over the raw logs and unpacked data for DisabledModule events raised by the ModuleManager contract.

func (*ModuleManagerDisabledModuleIterator) Close 

func (it *ModuleManagerDisabledModuleIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*ModuleManagerDisabledModuleIterator) Error 

func (it *ModuleManagerDisabledModuleIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ModuleManagerDisabledModuleIterator) Next 

func (it *ModuleManagerDisabledModuleIterator) Next() bool

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.

type ModuleManagerEnabledModule 

type ModuleManagerEnabledModule struct {
	Module common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

ModuleManagerEnabledModule represents a EnabledModule event raised by the ModuleManager contract.

type ModuleManagerEnabledModuleIterator 

type ModuleManagerEnabledModuleIterator struct {
	Event *ModuleManagerEnabledModule // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

ModuleManagerEnabledModuleIterator is returned from FilterEnabledModule and is used to iterate over the raw logs and unpacked data for EnabledModule events raised by the ModuleManager contract.

func (*ModuleManagerEnabledModuleIterator) Close 

func (it *ModuleManagerEnabledModuleIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*ModuleManagerEnabledModuleIterator) Error 

func (it *ModuleManagerEnabledModuleIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ModuleManagerEnabledModuleIterator) Next 

func (it *ModuleManagerEnabledModuleIterator) Next() bool

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.

type ModuleManagerExecutionFromModuleFailure 

type ModuleManagerExecutionFromModuleFailure struct {
	Module common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

ModuleManagerExecutionFromModuleFailure represents a ExecutionFromModuleFailure event raised by the ModuleManager contract.

type ModuleManagerExecutionFromModuleFailureIterator 

type ModuleManagerExecutionFromModuleFailureIterator struct {
	Event *ModuleManagerExecutionFromModuleFailure // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

ModuleManagerExecutionFromModuleFailureIterator is returned from FilterExecutionFromModuleFailure and is used to iterate over the raw logs and unpacked data for ExecutionFromModuleFailure events raised by the ModuleManager contract.

func (*ModuleManagerExecutionFromModuleFailureIterator) Close 

func (it *ModuleManagerExecutionFromModuleFailureIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*ModuleManagerExecutionFromModuleFailureIterator) Error 

func (it *ModuleManagerExecutionFromModuleFailureIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ModuleManagerExecutionFromModuleFailureIterator) Next 

func (it *ModuleManagerExecutionFromModuleFailureIterator) Next() bool

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.

type ModuleManagerExecutionFromModuleSuccess 

type ModuleManagerExecutionFromModuleSuccess struct {
	Module common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

ModuleManagerExecutionFromModuleSuccess represents a ExecutionFromModuleSuccess event raised by the ModuleManager contract.

type ModuleManagerExecutionFromModuleSuccessIterator 

type ModuleManagerExecutionFromModuleSuccessIterator struct {
	Event *ModuleManagerExecutionFromModuleSuccess // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

ModuleManagerExecutionFromModuleSuccessIterator is returned from FilterExecutionFromModuleSuccess and is used to iterate over the raw logs and unpacked data for ExecutionFromModuleSuccess events raised by the ModuleManager contract.

func (*ModuleManagerExecutionFromModuleSuccessIterator) Close 

func (it *ModuleManagerExecutionFromModuleSuccessIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*ModuleManagerExecutionFromModuleSuccessIterator) Error 

func (it *ModuleManagerExecutionFromModuleSuccessIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ModuleManagerExecutionFromModuleSuccessIterator) Next 

func (it *ModuleManagerExecutionFromModuleSuccessIterator) Next() bool

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.

type ModuleManagerFilterer 

type ModuleManagerFilterer struct {
	// contains filtered or unexported fields
}

ModuleManagerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewModuleManagerFilterer 

func NewModuleManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*ModuleManagerFilterer, error)

NewModuleManagerFilterer creates a new log filterer instance of ModuleManager, bound to a specific deployed contract.

func (*ModuleManagerFilterer) FilterDisabledModule 

func (_ModuleManager *ModuleManagerFilterer) FilterDisabledModule(opts *bind.FilterOpts) (*ModuleManagerDisabledModuleIterator, error)

FilterDisabledModule is a free log retrieval operation binding the contract event 0xaab4fa2b463f581b2b32cb3b7e3b704b9ce37cc209b5fb4d77e593ace4054276.

Solidity: event DisabledModule(address module)

func (*ModuleManagerFilterer) FilterEnabledModule 

func (_ModuleManager *ModuleManagerFilterer) FilterEnabledModule(opts *bind.FilterOpts) (*ModuleManagerEnabledModuleIterator, error)

FilterEnabledModule is a free log retrieval operation binding the contract event 0xecdf3a3effea5783a3c4c2140e677577666428d44ed9d474a0b3a4c9943f8440.

Solidity: event EnabledModule(address module)

func (*ModuleManagerFilterer) FilterExecutionFromModuleFailure 

func (_ModuleManager *ModuleManagerFilterer) FilterExecutionFromModuleFailure(opts *bind.FilterOpts, module []common.Address) (*ModuleManagerExecutionFromModuleFailureIterator, error)

FilterExecutionFromModuleFailure is a free log retrieval operation binding the contract event 0xacd2c8702804128fdb0db2bb49f6d127dd0181c13fd45dbfe16de0930e2bd375.

Solidity: event ExecutionFromModuleFailure(address indexed module)

func (*ModuleManagerFilterer) FilterExecutionFromModuleSuccess 

func (_ModuleManager *ModuleManagerFilterer) FilterExecutionFromModuleSuccess(opts *bind.FilterOpts, module []common.Address) (*ModuleManagerExecutionFromModuleSuccessIterator, error)

FilterExecutionFromModuleSuccess is a free log retrieval operation binding the contract event 0x6895c13664aa4f67288b25d7a21d7aaa34916e355fb9b6fae0a139a9085becb8.

Solidity: event ExecutionFromModuleSuccess(address indexed module)

func (*ModuleManagerFilterer) ParseDisabledModule 

func (_ModuleManager *ModuleManagerFilterer) ParseDisabledModule(log types.Log) (*ModuleManagerDisabledModule, error)

ParseDisabledModule is a log parse operation binding the contract event 0xaab4fa2b463f581b2b32cb3b7e3b704b9ce37cc209b5fb4d77e593ace4054276.

Solidity: event DisabledModule(address module)

func (*ModuleManagerFilterer) ParseEnabledModule 

func (_ModuleManager *ModuleManagerFilterer) ParseEnabledModule(log types.Log) (*ModuleManagerEnabledModule, error)

ParseEnabledModule is a log parse operation binding the contract event 0xecdf3a3effea5783a3c4c2140e677577666428d44ed9d474a0b3a4c9943f8440.

Solidity: event EnabledModule(address module)

func (*ModuleManagerFilterer) ParseExecutionFromModuleFailure 

func (_ModuleManager *ModuleManagerFilterer) ParseExecutionFromModuleFailure(log types.Log) (*ModuleManagerExecutionFromModuleFailure, error)

ParseExecutionFromModuleFailure is a log parse operation binding the contract event 0xacd2c8702804128fdb0db2bb49f6d127dd0181c13fd45dbfe16de0930e2bd375.

Solidity: event ExecutionFromModuleFailure(address indexed module)

func (*ModuleManagerFilterer) ParseExecutionFromModuleSuccess 

func (_ModuleManager *ModuleManagerFilterer) ParseExecutionFromModuleSuccess(log types.Log) (*ModuleManagerExecutionFromModuleSuccess, error)

ParseExecutionFromModuleSuccess is a log parse operation binding the contract event 0x6895c13664aa4f67288b25d7a21d7aaa34916e355fb9b6fae0a139a9085becb8.

Solidity: event ExecutionFromModuleSuccess(address indexed module)

func (*ModuleManagerFilterer) WatchDisabledModule 

func (_ModuleManager *ModuleManagerFilterer) WatchDisabledModule(opts *bind.WatchOpts, sink chan<- *ModuleManagerDisabledModule) (event.Subscription, error)

WatchDisabledModule is a free log subscription operation binding the contract event 0xaab4fa2b463f581b2b32cb3b7e3b704b9ce37cc209b5fb4d77e593ace4054276.

Solidity: event DisabledModule(address module)

func (*ModuleManagerFilterer) WatchEnabledModule 

func (_ModuleManager *ModuleManagerFilterer) WatchEnabledModule(opts *bind.WatchOpts, sink chan<- *ModuleManagerEnabledModule) (event.Subscription, error)

WatchEnabledModule is a free log subscription operation binding the contract event 0xecdf3a3effea5783a3c4c2140e677577666428d44ed9d474a0b3a4c9943f8440.

Solidity: event EnabledModule(address module)

func (*ModuleManagerFilterer) WatchExecutionFromModuleFailure 

func (_ModuleManager *ModuleManagerFilterer) WatchExecutionFromModuleFailure(opts *bind.WatchOpts, sink chan<- *ModuleManagerExecutionFromModuleFailure, module []common.Address) (event.Subscription, error)

WatchExecutionFromModuleFailure is a free log subscription operation binding the contract event 0xacd2c8702804128fdb0db2bb49f6d127dd0181c13fd45dbfe16de0930e2bd375.

Solidity: event ExecutionFromModuleFailure(address indexed module)

func (*ModuleManagerFilterer) WatchExecutionFromModuleSuccess 

func (_ModuleManager *ModuleManagerFilterer) WatchExecutionFromModuleSuccess(opts *bind.WatchOpts, sink chan<- *ModuleManagerExecutionFromModuleSuccess, module []common.Address) (event.Subscription, error)

WatchExecutionFromModuleSuccess is a free log subscription operation binding the contract event 0x6895c13664aa4f67288b25d7a21d7aaa34916e355fb9b6fae0a139a9085becb8.

Solidity: event ExecutionFromModuleSuccess(address indexed module)

type ModuleManagerRaw 

type ModuleManagerRaw struct {
	Contract *ModuleManager // Generic contract binding to access the raw methods on
}

ModuleManagerRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*ModuleManagerRaw) Call 

func (_ModuleManager *ModuleManagerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*ModuleManagerRaw) Transact 

func (_ModuleManager *ModuleManagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ModuleManagerRaw) Transfer 

func (_ModuleManager *ModuleManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ModuleManagerSession 

type ModuleManagerSession struct {
	Contract     *ModuleManager    // 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
}

ModuleManagerSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*ModuleManagerSession) DisableModule 

func (_ModuleManager *ModuleManagerSession) DisableModule(prevModule common.Address, module common.Address) (*types.Transaction, error)

DisableModule is a paid mutator transaction binding the contract method 0xe009cfde.

Solidity: function disableModule(address prevModule, address module) returns()

func (*ModuleManagerSession) EnableModule 

func (_ModuleManager *ModuleManagerSession) EnableModule(module common.Address) (*types.Transaction, error)

EnableModule is a paid mutator transaction binding the contract method 0x610b5925.

Solidity: function enableModule(address module) returns()

func (*ModuleManagerSession) ExecTransactionFromModule 

func (_ModuleManager *ModuleManagerSession) ExecTransactionFromModule(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

ExecTransactionFromModule is a paid mutator transaction binding the contract method 0x468721a7.

Solidity: function execTransactionFromModule(address to, uint256 value, bytes data, uint8 operation) returns(bool success)

func (*ModuleManagerSession) ExecTransactionFromModuleReturnData 

func (_ModuleManager *ModuleManagerSession) ExecTransactionFromModuleReturnData(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

ExecTransactionFromModuleReturnData is a paid mutator transaction binding the contract method 0x5229073f.

Solidity: function execTransactionFromModuleReturnData(address to, uint256 value, bytes data, uint8 operation) returns(bool success, bytes returnData)

func (*ModuleManagerSession) GetModulesPaginated 

func (_ModuleManager *ModuleManagerSession) GetModulesPaginated(start common.Address, pageSize *big.Int) (struct {
	Array []common.Address
	Next  common.Address
}, error)

GetModulesPaginated is a free data retrieval call binding the contract method 0xcc2f8452.

Solidity: function getModulesPaginated(address start, uint256 pageSize) view returns(address[] array, address next)

func (*ModuleManagerSession) IsModuleEnabled 

func (_ModuleManager *ModuleManagerSession) IsModuleEnabled(module common.Address) (bool, error)

IsModuleEnabled is a free data retrieval call binding the contract method 0x2d9ad53d.

Solidity: function isModuleEnabled(address module) view returns(bool)

type ModuleManagerTransactor 

type ModuleManagerTransactor struct {
	// contains filtered or unexported fields
}

ModuleManagerTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewModuleManagerTransactor 

func NewModuleManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*ModuleManagerTransactor, error)

NewModuleManagerTransactor creates a new write-only instance of ModuleManager, bound to a specific deployed contract.

func (*ModuleManagerTransactor) DisableModule 

func (_ModuleManager *ModuleManagerTransactor) DisableModule(opts *bind.TransactOpts, prevModule common.Address, module common.Address) (*types.Transaction, error)

DisableModule is a paid mutator transaction binding the contract method 0xe009cfde.

Solidity: function disableModule(address prevModule, address module) returns()

func (*ModuleManagerTransactor) EnableModule 

func (_ModuleManager *ModuleManagerTransactor) EnableModule(opts *bind.TransactOpts, module common.Address) (*types.Transaction, error)

EnableModule is a paid mutator transaction binding the contract method 0x610b5925.

Solidity: function enableModule(address module) returns()

func (*ModuleManagerTransactor) ExecTransactionFromModule 

func (_ModuleManager *ModuleManagerTransactor) ExecTransactionFromModule(opts *bind.TransactOpts, to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

ExecTransactionFromModule is a paid mutator transaction binding the contract method 0x468721a7.

Solidity: function execTransactionFromModule(address to, uint256 value, bytes data, uint8 operation) returns(bool success)

func (*ModuleManagerTransactor) ExecTransactionFromModuleReturnData 

func (_ModuleManager *ModuleManagerTransactor) ExecTransactionFromModuleReturnData(opts *bind.TransactOpts, to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

ExecTransactionFromModuleReturnData is a paid mutator transaction binding the contract method 0x5229073f.

Solidity: function execTransactionFromModuleReturnData(address to, uint256 value, bytes data, uint8 operation) returns(bool success, bytes returnData)

type ModuleManagerTransactorRaw 

type ModuleManagerTransactorRaw struct {
	Contract *ModuleManagerTransactor // Generic write-only contract binding to access the raw methods on
}

ModuleManagerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*ModuleManagerTransactorRaw) Transact 

func (_ModuleManager *ModuleManagerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*ModuleManagerTransactorRaw) Transfer 

func (_ModuleManager *ModuleManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type ModuleManagerTransactorSession 

type ModuleManagerTransactorSession struct {
	Contract     *ModuleManagerTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
}

ModuleManagerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*ModuleManagerTransactorSession) DisableModule 

func (_ModuleManager *ModuleManagerTransactorSession) DisableModule(prevModule common.Address, module common.Address) (*types.Transaction, error)

DisableModule is a paid mutator transaction binding the contract method 0xe009cfde.

Solidity: function disableModule(address prevModule, address module) returns()

func (*ModuleManagerTransactorSession) EnableModule 

func (_ModuleManager *ModuleManagerTransactorSession) EnableModule(module common.Address) (*types.Transaction, error)

EnableModule is a paid mutator transaction binding the contract method 0x610b5925.

Solidity: function enableModule(address module) returns()

func (*ModuleManagerTransactorSession) ExecTransactionFromModule 

func (_ModuleManager *ModuleManagerTransactorSession) ExecTransactionFromModule(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

ExecTransactionFromModule is a paid mutator transaction binding the contract method 0x468721a7.

Solidity: function execTransactionFromModule(address to, uint256 value, bytes data, uint8 operation) returns(bool success)

func (*ModuleManagerTransactorSession) ExecTransactionFromModuleReturnData 

func (_ModuleManager *ModuleManagerTransactorSession) ExecTransactionFromModuleReturnData(to common.Address, value *big.Int, data []byte, operation uint8) (*types.Transaction, error)

ExecTransactionFromModuleReturnData is a paid mutator transaction binding the contract method 0x5229073f.

Solidity: function execTransactionFromModuleReturnData(address to, uint256 value, bytes data, uint8 operation) returns(bool success, bytes returnData)

type OwnerManager 

type OwnerManager struct {
	OwnerManagerCaller     // Read-only binding to the contract
	OwnerManagerTransactor // Write-only binding to the contract
	OwnerManagerFilterer   // Log filterer for contract events
}

OwnerManager is an auto generated Go binding around an Ethereum contract.

func DeployOwnerManager 

func DeployOwnerManager(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *OwnerManager, error)

DeployOwnerManager deploys a new Ethereum contract, binding an instance of OwnerManager to it.

func NewOwnerManager 

func NewOwnerManager(address common.Address, backend bind.ContractBackend) (*OwnerManager, error)

NewOwnerManager creates a new instance of OwnerManager, bound to a specific deployed contract.

type OwnerManagerAddedOwner 

type OwnerManagerAddedOwner struct {
	Owner common.Address
	Raw   types.Log // Blockchain specific contextual infos
}

OwnerManagerAddedOwner represents a AddedOwner event raised by the OwnerManager contract.

type OwnerManagerAddedOwnerIterator 

type OwnerManagerAddedOwnerIterator struct {
	Event *OwnerManagerAddedOwner // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

OwnerManagerAddedOwnerIterator is returned from FilterAddedOwner and is used to iterate over the raw logs and unpacked data for AddedOwner events raised by the OwnerManager contract.

func (*OwnerManagerAddedOwnerIterator) Close 

func (it *OwnerManagerAddedOwnerIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*OwnerManagerAddedOwnerIterator) Error 

func (it *OwnerManagerAddedOwnerIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*OwnerManagerAddedOwnerIterator) Next 

func (it *OwnerManagerAddedOwnerIterator) Next() bool

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.

type OwnerManagerCaller 

type OwnerManagerCaller struct {
	// contains filtered or unexported fields
}

OwnerManagerCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewOwnerManagerCaller 

func NewOwnerManagerCaller(address common.Address, caller bind.ContractCaller) (*OwnerManagerCaller, error)

NewOwnerManagerCaller creates a new read-only instance of OwnerManager, bound to a specific deployed contract.

func (*OwnerManagerCaller) GetOwners 

func (_OwnerManager *OwnerManagerCaller) GetOwners(opts *bind.CallOpts) ([]common.Address, error)

GetOwners is a free data retrieval call binding the contract method 0xa0e67e2b.

Solidity: function getOwners() view returns(address[])

func (*OwnerManagerCaller) GetThreshold 

func (_OwnerManager *OwnerManagerCaller) GetThreshold(opts *bind.CallOpts) (*big.Int, error)

GetThreshold is a free data retrieval call binding the contract method 0xe75235b8.

Solidity: function getThreshold() view returns(uint256)

func (*OwnerManagerCaller) IsOwner 

func (_OwnerManager *OwnerManagerCaller) IsOwner(opts *bind.CallOpts, owner common.Address) (bool, error)

IsOwner is a free data retrieval call binding the contract method 0x2f54bf6e.

Solidity: function isOwner(address owner) view returns(bool)

type OwnerManagerCallerRaw 

type OwnerManagerCallerRaw struct {
	Contract *OwnerManagerCaller // Generic read-only contract binding to access the raw methods on
}

OwnerManagerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*OwnerManagerCallerRaw) Call 

func (_OwnerManager *OwnerManagerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type OwnerManagerCallerSession 

type OwnerManagerCallerSession struct {
	Contract *OwnerManagerCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts       // Call options to use throughout this session
}

OwnerManagerCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*OwnerManagerCallerSession) GetOwners 

func (_OwnerManager *OwnerManagerCallerSession) GetOwners() ([]common.Address, error)

GetOwners is a free data retrieval call binding the contract method 0xa0e67e2b.

Solidity: function getOwners() view returns(address[])

func (*OwnerManagerCallerSession) GetThreshold 

func (_OwnerManager *OwnerManagerCallerSession) GetThreshold() (*big.Int, error)

GetThreshold is a free data retrieval call binding the contract method 0xe75235b8.

Solidity: function getThreshold() view returns(uint256)

func (*OwnerManagerCallerSession) IsOwner 

func (_OwnerManager *OwnerManagerCallerSession) IsOwner(owner common.Address) (bool, error)

IsOwner is a free data retrieval call binding the contract method 0x2f54bf6e.

Solidity: function isOwner(address owner) view returns(bool)

type OwnerManagerChangedThreshold 

type OwnerManagerChangedThreshold struct {
	Threshold *big.Int
	Raw       types.Log // Blockchain specific contextual infos
}

OwnerManagerChangedThreshold represents a ChangedThreshold event raised by the OwnerManager contract.

type OwnerManagerChangedThresholdIterator 

type OwnerManagerChangedThresholdIterator struct {
	Event *OwnerManagerChangedThreshold // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

OwnerManagerChangedThresholdIterator is returned from FilterChangedThreshold and is used to iterate over the raw logs and unpacked data for ChangedThreshold events raised by the OwnerManager contract.

func (*OwnerManagerChangedThresholdIterator) Close 

func (it *OwnerManagerChangedThresholdIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*OwnerManagerChangedThresholdIterator) Error 

func (it *OwnerManagerChangedThresholdIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*OwnerManagerChangedThresholdIterator) Next 

func (it *OwnerManagerChangedThresholdIterator) Next() bool

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.

type OwnerManagerFilterer 

type OwnerManagerFilterer struct {
	// contains filtered or unexported fields
}

OwnerManagerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewOwnerManagerFilterer 

func NewOwnerManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnerManagerFilterer, error)

NewOwnerManagerFilterer creates a new log filterer instance of OwnerManager, bound to a specific deployed contract.

func (*OwnerManagerFilterer) FilterAddedOwner 

func (_OwnerManager *OwnerManagerFilterer) FilterAddedOwner(opts *bind.FilterOpts) (*OwnerManagerAddedOwnerIterator, error)

FilterAddedOwner is a free log retrieval operation binding the contract event 0x9465fa0c962cc76958e6373a993326400c1c94f8be2fe3a952adfa7f60b2ea26.

Solidity: event AddedOwner(address owner)

func (*OwnerManagerFilterer) FilterChangedThreshold 

func (_OwnerManager *OwnerManagerFilterer) FilterChangedThreshold(opts *bind.FilterOpts) (*OwnerManagerChangedThresholdIterator, error)

FilterChangedThreshold is a free log retrieval operation binding the contract event 0x610f7ff2b304ae8903c3de74c60c6ab1f7d6226b3f52c5161905bb5ad4039c93.

Solidity: event ChangedThreshold(uint256 threshold)

func (*OwnerManagerFilterer) FilterRemovedOwner 

func (_OwnerManager *OwnerManagerFilterer) FilterRemovedOwner(opts *bind.FilterOpts) (*OwnerManagerRemovedOwnerIterator, error)

FilterRemovedOwner is a free log retrieval operation binding the contract event 0xf8d49fc529812e9a7c5c50e69c20f0dccc0db8fa95c98bc58cc9a4f1c1299eaf.

Solidity: event RemovedOwner(address owner)

func (*OwnerManagerFilterer) ParseAddedOwner 

func (_OwnerManager *OwnerManagerFilterer) ParseAddedOwner(log types.Log) (*OwnerManagerAddedOwner, error)

ParseAddedOwner is a log parse operation binding the contract event 0x9465fa0c962cc76958e6373a993326400c1c94f8be2fe3a952adfa7f60b2ea26.

Solidity: event AddedOwner(address owner)

func (*OwnerManagerFilterer) ParseChangedThreshold 

func (_OwnerManager *OwnerManagerFilterer) ParseChangedThreshold(log types.Log) (*OwnerManagerChangedThreshold, error)

ParseChangedThreshold is a log parse operation binding the contract event 0x610f7ff2b304ae8903c3de74c60c6ab1f7d6226b3f52c5161905bb5ad4039c93.

Solidity: event ChangedThreshold(uint256 threshold)

func (*OwnerManagerFilterer) ParseRemovedOwner 

func (_OwnerManager *OwnerManagerFilterer) ParseRemovedOwner(log types.Log) (*OwnerManagerRemovedOwner, error)

ParseRemovedOwner is a log parse operation binding the contract event 0xf8d49fc529812e9a7c5c50e69c20f0dccc0db8fa95c98bc58cc9a4f1c1299eaf.

Solidity: event RemovedOwner(address owner)

func (*OwnerManagerFilterer) WatchAddedOwner 

func (_OwnerManager *OwnerManagerFilterer) WatchAddedOwner(opts *bind.WatchOpts, sink chan<- *OwnerManagerAddedOwner) (event.Subscription, error)

WatchAddedOwner is a free log subscription operation binding the contract event 0x9465fa0c962cc76958e6373a993326400c1c94f8be2fe3a952adfa7f60b2ea26.

Solidity: event AddedOwner(address owner)

func (*OwnerManagerFilterer) WatchChangedThreshold 

func (_OwnerManager *OwnerManagerFilterer) WatchChangedThreshold(opts *bind.WatchOpts, sink chan<- *OwnerManagerChangedThreshold) (event.Subscription, error)

WatchChangedThreshold is a free log subscription operation binding the contract event 0x610f7ff2b304ae8903c3de74c60c6ab1f7d6226b3f52c5161905bb5ad4039c93.

Solidity: event ChangedThreshold(uint256 threshold)

func (*OwnerManagerFilterer) WatchRemovedOwner 

func (_OwnerManager *OwnerManagerFilterer) WatchRemovedOwner(opts *bind.WatchOpts, sink chan<- *OwnerManagerRemovedOwner) (event.Subscription, error)

WatchRemovedOwner is a free log subscription operation binding the contract event 0xf8d49fc529812e9a7c5c50e69c20f0dccc0db8fa95c98bc58cc9a4f1c1299eaf.

Solidity: event RemovedOwner(address owner)

type OwnerManagerRaw 

type OwnerManagerRaw struct {
	Contract *OwnerManager // Generic contract binding to access the raw methods on
}

OwnerManagerRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*OwnerManagerRaw) Call 

func (_OwnerManager *OwnerManagerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*OwnerManagerRaw) Transact 

func (_OwnerManager *OwnerManagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*OwnerManagerRaw) Transfer 

func (_OwnerManager *OwnerManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type OwnerManagerRemovedOwner 

type OwnerManagerRemovedOwner struct {
	Owner common.Address
	Raw   types.Log // Blockchain specific contextual infos
}

OwnerManagerRemovedOwner represents a RemovedOwner event raised by the OwnerManager contract.

type OwnerManagerRemovedOwnerIterator 

type OwnerManagerRemovedOwnerIterator struct {
	Event *OwnerManagerRemovedOwner // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

OwnerManagerRemovedOwnerIterator is returned from FilterRemovedOwner and is used to iterate over the raw logs and unpacked data for RemovedOwner events raised by the OwnerManager contract.

func (*OwnerManagerRemovedOwnerIterator) Close 

func (it *OwnerManagerRemovedOwnerIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*OwnerManagerRemovedOwnerIterator) Error 

func (it *OwnerManagerRemovedOwnerIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*OwnerManagerRemovedOwnerIterator) Next 

func (it *OwnerManagerRemovedOwnerIterator) Next() bool

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.

type OwnerManagerSession 

type OwnerManagerSession struct {
	Contract     *OwnerManager     // 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
}

OwnerManagerSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*OwnerManagerSession) AddOwnerWithThreshold 

func (_OwnerManager *OwnerManagerSession) AddOwnerWithThreshold(owner common.Address, _threshold *big.Int) (*types.Transaction, error)

AddOwnerWithThreshold is a paid mutator transaction binding the contract method 0x0d582f13.

Solidity: function addOwnerWithThreshold(address owner, uint256 _threshold) returns()

func (*OwnerManagerSession) ChangeThreshold 

func (_OwnerManager *OwnerManagerSession) ChangeThreshold(_threshold *big.Int) (*types.Transaction, error)

ChangeThreshold is a paid mutator transaction binding the contract method 0x694e80c3.

Solidity: function changeThreshold(uint256 _threshold) returns()

func (*OwnerManagerSession) GetOwners 

func (_OwnerManager *OwnerManagerSession) GetOwners() ([]common.Address, error)

GetOwners is a free data retrieval call binding the contract method 0xa0e67e2b.

Solidity: function getOwners() view returns(address[])

func (*OwnerManagerSession) GetThreshold 

func (_OwnerManager *OwnerManagerSession) GetThreshold() (*big.Int, error)

GetThreshold is a free data retrieval call binding the contract method 0xe75235b8.

Solidity: function getThreshold() view returns(uint256)

func (*OwnerManagerSession) IsOwner 

func (_OwnerManager *OwnerManagerSession) IsOwner(owner common.Address) (bool, error)

IsOwner is a free data retrieval call binding the contract method 0x2f54bf6e.

Solidity: function isOwner(address owner) view returns(bool)

func (*OwnerManagerSession) RemoveOwner 

func (_OwnerManager *OwnerManagerSession) RemoveOwner(prevOwner common.Address, owner common.Address, _threshold *big.Int) (*types.Transaction, error)

RemoveOwner is a paid mutator transaction binding the contract method 0xf8dc5dd9.

Solidity: function removeOwner(address prevOwner, address owner, uint256 _threshold) returns()

func (*OwnerManagerSession) SwapOwner 

func (_OwnerManager *OwnerManagerSession) SwapOwner(prevOwner common.Address, oldOwner common.Address, newOwner common.Address) (*types.Transaction, error)

SwapOwner is a paid mutator transaction binding the contract method 0xe318b52b.

Solidity: function swapOwner(address prevOwner, address oldOwner, address newOwner) returns()

type OwnerManagerTransactor 

type OwnerManagerTransactor struct {
	// contains filtered or unexported fields
}

OwnerManagerTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewOwnerManagerTransactor 

func NewOwnerManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnerManagerTransactor, error)

NewOwnerManagerTransactor creates a new write-only instance of OwnerManager, bound to a specific deployed contract.

func (*OwnerManagerTransactor) AddOwnerWithThreshold 

func (_OwnerManager *OwnerManagerTransactor) AddOwnerWithThreshold(opts *bind.TransactOpts, owner common.Address, _threshold *big.Int) (*types.Transaction, error)

AddOwnerWithThreshold is a paid mutator transaction binding the contract method 0x0d582f13.

Solidity: function addOwnerWithThreshold(address owner, uint256 _threshold) returns()

func (*OwnerManagerTransactor) ChangeThreshold 

func (_OwnerManager *OwnerManagerTransactor) ChangeThreshold(opts *bind.TransactOpts, _threshold *big.Int) (*types.Transaction, error)

ChangeThreshold is a paid mutator transaction binding the contract method 0x694e80c3.

Solidity: function changeThreshold(uint256 _threshold) returns()

func (*OwnerManagerTransactor) RemoveOwner 

func (_OwnerManager *OwnerManagerTransactor) RemoveOwner(opts *bind.TransactOpts, prevOwner common.Address, owner common.Address, _threshold *big.Int) (*types.Transaction, error)

RemoveOwner is a paid mutator transaction binding the contract method 0xf8dc5dd9.

Solidity: function removeOwner(address prevOwner, address owner, uint256 _threshold) returns()

func (*OwnerManagerTransactor) SwapOwner 

func (_OwnerManager *OwnerManagerTransactor) SwapOwner(opts *bind.TransactOpts, prevOwner common.Address, oldOwner common.Address, newOwner common.Address) (*types.Transaction, error)

SwapOwner is a paid mutator transaction binding the contract method 0xe318b52b.

Solidity: function swapOwner(address prevOwner, address oldOwner, address newOwner) returns()

type OwnerManagerTransactorRaw 

type OwnerManagerTransactorRaw struct {
	Contract *OwnerManagerTransactor // Generic write-only contract binding to access the raw methods on
}

OwnerManagerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*OwnerManagerTransactorRaw) Transact 

func (_OwnerManager *OwnerManagerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*OwnerManagerTransactorRaw) Transfer 

func (_OwnerManager *OwnerManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type OwnerManagerTransactorSession 

type OwnerManagerTransactorSession struct {
	Contract     *OwnerManagerTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts       // Transaction auth options to use throughout this session
}

OwnerManagerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*OwnerManagerTransactorSession) AddOwnerWithThreshold 

func (_OwnerManager *OwnerManagerTransactorSession) AddOwnerWithThreshold(owner common.Address, _threshold *big.Int) (*types.Transaction, error)

AddOwnerWithThreshold is a paid mutator transaction binding the contract method 0x0d582f13.

Solidity: function addOwnerWithThreshold(address owner, uint256 _threshold) returns()

func (*OwnerManagerTransactorSession) ChangeThreshold 

func (_OwnerManager *OwnerManagerTransactorSession) ChangeThreshold(_threshold *big.Int) (*types.Transaction, error)

ChangeThreshold is a paid mutator transaction binding the contract method 0x694e80c3.

Solidity: function changeThreshold(uint256 _threshold) returns()

func (*OwnerManagerTransactorSession) RemoveOwner 

func (_OwnerManager *OwnerManagerTransactorSession) RemoveOwner(prevOwner common.Address, owner common.Address, _threshold *big.Int) (*types.Transaction, error)

RemoveOwner is a paid mutator transaction binding the contract method 0xf8dc5dd9.

Solidity: function removeOwner(address prevOwner, address owner, uint256 _threshold) returns()

func (*OwnerManagerTransactorSession) SwapOwner 

func (_OwnerManager *OwnerManagerTransactorSession) SwapOwner(prevOwner common.Address, oldOwner common.Address, newOwner common.Address) (*types.Transaction, error)

SwapOwner is a paid mutator transaction binding the contract method 0xe318b52b.

Solidity: function swapOwner(address prevOwner, address oldOwner, address newOwner) returns()

type SecuredTokenTransfer 

type SecuredTokenTransfer struct {
	SecuredTokenTransferCaller     // Read-only binding to the contract
	SecuredTokenTransferTransactor // Write-only binding to the contract
	SecuredTokenTransferFilterer   // Log filterer for contract events
}

SecuredTokenTransfer is an auto generated Go binding around an Ethereum contract.

func DeploySecuredTokenTransfer 

func DeploySecuredTokenTransfer(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SecuredTokenTransfer, error)

DeploySecuredTokenTransfer deploys a new Ethereum contract, binding an instance of SecuredTokenTransfer to it.

func NewSecuredTokenTransfer 

func NewSecuredTokenTransfer(address common.Address, backend bind.ContractBackend) (*SecuredTokenTransfer, error)

NewSecuredTokenTransfer creates a new instance of SecuredTokenTransfer, bound to a specific deployed contract.

type SecuredTokenTransferCaller 

type SecuredTokenTransferCaller struct {
	// contains filtered or unexported fields
}

SecuredTokenTransferCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewSecuredTokenTransferCaller 

func NewSecuredTokenTransferCaller(address common.Address, caller bind.ContractCaller) (*SecuredTokenTransferCaller, error)

NewSecuredTokenTransferCaller creates a new read-only instance of SecuredTokenTransfer, bound to a specific deployed contract.

type SecuredTokenTransferCallerRaw 

type SecuredTokenTransferCallerRaw struct {
	Contract *SecuredTokenTransferCaller // Generic read-only contract binding to access the raw methods on
}

SecuredTokenTransferCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*SecuredTokenTransferCallerRaw) Call 

func (_SecuredTokenTransfer *SecuredTokenTransferCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type SecuredTokenTransferCallerSession 

type SecuredTokenTransferCallerSession struct {
	Contract *SecuredTokenTransferCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts               // Call options to use throughout this session
}

SecuredTokenTransferCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type SecuredTokenTransferFilterer 

type SecuredTokenTransferFilterer struct {
	// contains filtered or unexported fields
}

SecuredTokenTransferFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewSecuredTokenTransferFilterer 

func NewSecuredTokenTransferFilterer(address common.Address, filterer bind.ContractFilterer) (*SecuredTokenTransferFilterer, error)

NewSecuredTokenTransferFilterer creates a new log filterer instance of SecuredTokenTransfer, bound to a specific deployed contract.

type SecuredTokenTransferRaw 

type SecuredTokenTransferRaw struct {
	Contract *SecuredTokenTransfer // Generic contract binding to access the raw methods on
}

SecuredTokenTransferRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*SecuredTokenTransferRaw) Call 

func (_SecuredTokenTransfer *SecuredTokenTransferRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*SecuredTokenTransferRaw) Transact 

func (_SecuredTokenTransfer *SecuredTokenTransferRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*SecuredTokenTransferRaw) Transfer 

func (_SecuredTokenTransfer *SecuredTokenTransferRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type SecuredTokenTransferSession 

type SecuredTokenTransferSession struct {
	Contract     *SecuredTokenTransfer // 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
}

SecuredTokenTransferSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type SecuredTokenTransferTransactor 

type SecuredTokenTransferTransactor struct {
	// contains filtered or unexported fields
}

SecuredTokenTransferTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewSecuredTokenTransferTransactor 

func NewSecuredTokenTransferTransactor(address common.Address, transactor bind.ContractTransactor) (*SecuredTokenTransferTransactor, error)

NewSecuredTokenTransferTransactor creates a new write-only instance of SecuredTokenTransfer, bound to a specific deployed contract.

type SecuredTokenTransferTransactorRaw 

type SecuredTokenTransferTransactorRaw struct {
	Contract *SecuredTokenTransferTransactor // Generic write-only contract binding to access the raw methods on
}

SecuredTokenTransferTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*SecuredTokenTransferTransactorRaw) Transact 

func (_SecuredTokenTransfer *SecuredTokenTransferTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*SecuredTokenTransferTransactorRaw) Transfer 

func (_SecuredTokenTransfer *SecuredTokenTransferTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type SecuredTokenTransferTransactorSession 

type SecuredTokenTransferTransactorSession struct {
	Contract     *SecuredTokenTransferTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts               // Transaction auth options to use throughout this session
}

SecuredTokenTransferTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type SelfAuthorized 

type SelfAuthorized struct {
	SelfAuthorizedCaller     // Read-only binding to the contract
	SelfAuthorizedTransactor // Write-only binding to the contract
	SelfAuthorizedFilterer   // Log filterer for contract events
}

SelfAuthorized is an auto generated Go binding around an Ethereum contract.

func DeploySelfAuthorized 

func DeploySelfAuthorized(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SelfAuthorized, error)

DeploySelfAuthorized deploys a new Ethereum contract, binding an instance of SelfAuthorized to it.

func NewSelfAuthorized 

func NewSelfAuthorized(address common.Address, backend bind.ContractBackend) (*SelfAuthorized, error)

NewSelfAuthorized creates a new instance of SelfAuthorized, bound to a specific deployed contract.

type SelfAuthorizedCaller 

type SelfAuthorizedCaller struct {
	// contains filtered or unexported fields
}

SelfAuthorizedCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewSelfAuthorizedCaller 

func NewSelfAuthorizedCaller(address common.Address, caller bind.ContractCaller) (*SelfAuthorizedCaller, error)

NewSelfAuthorizedCaller creates a new read-only instance of SelfAuthorized, bound to a specific deployed contract.

type SelfAuthorizedCallerRaw 

type SelfAuthorizedCallerRaw struct {
	Contract *SelfAuthorizedCaller // Generic read-only contract binding to access the raw methods on
}

SelfAuthorizedCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*SelfAuthorizedCallerRaw) Call 

func (_SelfAuthorized *SelfAuthorizedCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type SelfAuthorizedCallerSession 

type SelfAuthorizedCallerSession struct {
	Contract *SelfAuthorizedCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts         // Call options to use throughout this session
}

SelfAuthorizedCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type SelfAuthorizedFilterer 

type SelfAuthorizedFilterer struct {
	// contains filtered or unexported fields
}

SelfAuthorizedFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewSelfAuthorizedFilterer 

func NewSelfAuthorizedFilterer(address common.Address, filterer bind.ContractFilterer) (*SelfAuthorizedFilterer, error)

NewSelfAuthorizedFilterer creates a new log filterer instance of SelfAuthorized, bound to a specific deployed contract.

type SelfAuthorizedRaw 

type SelfAuthorizedRaw struct {
	Contract *SelfAuthorized // Generic contract binding to access the raw methods on
}

SelfAuthorizedRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*SelfAuthorizedRaw) Call 

func (_SelfAuthorized *SelfAuthorizedRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*SelfAuthorizedRaw) Transact 

func (_SelfAuthorized *SelfAuthorizedRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*SelfAuthorizedRaw) Transfer 

func (_SelfAuthorized *SelfAuthorizedRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type SelfAuthorizedSession 

type SelfAuthorizedSession struct {
	Contract     *SelfAuthorized   // 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
}

SelfAuthorizedSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type SelfAuthorizedTransactor 

type SelfAuthorizedTransactor struct {
	// contains filtered or unexported fields
}

SelfAuthorizedTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewSelfAuthorizedTransactor 

func NewSelfAuthorizedTransactor(address common.Address, transactor bind.ContractTransactor) (*SelfAuthorizedTransactor, error)

NewSelfAuthorizedTransactor creates a new write-only instance of SelfAuthorized, bound to a specific deployed contract.

type SelfAuthorizedTransactorRaw 

type SelfAuthorizedTransactorRaw struct {
	Contract *SelfAuthorizedTransactor // Generic write-only contract binding to access the raw methods on
}

SelfAuthorizedTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*SelfAuthorizedTransactorRaw) Transact 

func (_SelfAuthorized *SelfAuthorizedTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*SelfAuthorizedTransactorRaw) Transfer 

func (_SelfAuthorized *SelfAuthorizedTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type SelfAuthorizedTransactorSession 

type SelfAuthorizedTransactorSession struct {
	Contract     *SelfAuthorizedTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
}

SelfAuthorizedTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type SignatureDecoder 

type SignatureDecoder struct {
	SignatureDecoderCaller     // Read-only binding to the contract
	SignatureDecoderTransactor // Write-only binding to the contract
	SignatureDecoderFilterer   // Log filterer for contract events
}

SignatureDecoder is an auto generated Go binding around an Ethereum contract.

func DeploySignatureDecoder 

func DeploySignatureDecoder(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SignatureDecoder, error)

DeploySignatureDecoder deploys a new Ethereum contract, binding an instance of SignatureDecoder to it.

func NewSignatureDecoder 

func NewSignatureDecoder(address common.Address, backend bind.ContractBackend) (*SignatureDecoder, error)

NewSignatureDecoder creates a new instance of SignatureDecoder, bound to a specific deployed contract.

type SignatureDecoderCaller 

type SignatureDecoderCaller struct {
	// contains filtered or unexported fields
}

SignatureDecoderCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewSignatureDecoderCaller 

func NewSignatureDecoderCaller(address common.Address, caller bind.ContractCaller) (*SignatureDecoderCaller, error)

NewSignatureDecoderCaller creates a new read-only instance of SignatureDecoder, bound to a specific deployed contract.

type SignatureDecoderCallerRaw 

type SignatureDecoderCallerRaw struct {
	Contract *SignatureDecoderCaller // Generic read-only contract binding to access the raw methods on
}

SignatureDecoderCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*SignatureDecoderCallerRaw) Call 

func (_SignatureDecoder *SignatureDecoderCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type SignatureDecoderCallerSession 

type SignatureDecoderCallerSession struct {
	Contract *SignatureDecoderCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts           // Call options to use throughout this session
}

SignatureDecoderCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type SignatureDecoderFilterer 

type SignatureDecoderFilterer struct {
	// contains filtered or unexported fields
}

SignatureDecoderFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewSignatureDecoderFilterer 

func NewSignatureDecoderFilterer(address common.Address, filterer bind.ContractFilterer) (*SignatureDecoderFilterer, error)

NewSignatureDecoderFilterer creates a new log filterer instance of SignatureDecoder, bound to a specific deployed contract.

type SignatureDecoderRaw 

type SignatureDecoderRaw struct {
	Contract *SignatureDecoder // Generic contract binding to access the raw methods on
}

SignatureDecoderRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*SignatureDecoderRaw) Call 

func (_SignatureDecoder *SignatureDecoderRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*SignatureDecoderRaw) Transact 

func (_SignatureDecoder *SignatureDecoderRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*SignatureDecoderRaw) Transfer 

func (_SignatureDecoder *SignatureDecoderRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type SignatureDecoderSession 

type SignatureDecoderSession struct {
	Contract     *SignatureDecoder // 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
}

SignatureDecoderSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type SignatureDecoderTransactor 

type SignatureDecoderTransactor struct {
	// contains filtered or unexported fields
}

SignatureDecoderTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewSignatureDecoderTransactor 

func NewSignatureDecoderTransactor(address common.Address, transactor bind.ContractTransactor) (*SignatureDecoderTransactor, error)

NewSignatureDecoderTransactor creates a new write-only instance of SignatureDecoder, bound to a specific deployed contract.

type SignatureDecoderTransactorRaw 

type SignatureDecoderTransactorRaw struct {
	Contract *SignatureDecoderTransactor // Generic write-only contract binding to access the raw methods on
}

SignatureDecoderTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*SignatureDecoderTransactorRaw) Transact 

func (_SignatureDecoder *SignatureDecoderTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*SignatureDecoderTransactorRaw) Transfer 

func (_SignatureDecoder *SignatureDecoderTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type SignatureDecoderTransactorSession 

type SignatureDecoderTransactorSession struct {
	Contract     *SignatureDecoderTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts           // Transaction auth options to use throughout this session
}

SignatureDecoderTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type Singleton 

type Singleton struct {
	SingletonCaller     // Read-only binding to the contract
	SingletonTransactor // Write-only binding to the contract
	SingletonFilterer   // Log filterer for contract events
}

Singleton is an auto generated Go binding around an Ethereum contract.

func DeploySingleton 

func DeploySingleton(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Singleton, error)

DeploySingleton deploys a new Ethereum contract, binding an instance of Singleton to it.

func NewSingleton 

func NewSingleton(address common.Address, backend bind.ContractBackend) (*Singleton, error)

NewSingleton creates a new instance of Singleton, bound to a specific deployed contract.

type SingletonCaller 

type SingletonCaller struct {
	// contains filtered or unexported fields
}

SingletonCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewSingletonCaller 

func NewSingletonCaller(address common.Address, caller bind.ContractCaller) (*SingletonCaller, error)

NewSingletonCaller creates a new read-only instance of Singleton, bound to a specific deployed contract.

type SingletonCallerRaw 

type SingletonCallerRaw struct {
	Contract *SingletonCaller // Generic read-only contract binding to access the raw methods on
}

SingletonCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*SingletonCallerRaw) Call 

func (_Singleton *SingletonCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type SingletonCallerSession 

type SingletonCallerSession struct {
	Contract *SingletonCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts    // Call options to use throughout this session
}

SingletonCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type SingletonFilterer 

type SingletonFilterer struct {
	// contains filtered or unexported fields
}

SingletonFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewSingletonFilterer 

func NewSingletonFilterer(address common.Address, filterer bind.ContractFilterer) (*SingletonFilterer, error)

NewSingletonFilterer creates a new log filterer instance of Singleton, bound to a specific deployed contract.

type SingletonRaw 

type SingletonRaw struct {
	Contract *Singleton // Generic contract binding to access the raw methods on
}

SingletonRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*SingletonRaw) Call 

func (_Singleton *SingletonRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*SingletonRaw) Transact 

func (_Singleton *SingletonRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*SingletonRaw) Transfer 

func (_Singleton *SingletonRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type SingletonSession 

type SingletonSession struct {
	Contract     *Singleton        // 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
}

SingletonSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

type SingletonTransactor 

type SingletonTransactor struct {
	// contains filtered or unexported fields
}

SingletonTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewSingletonTransactor 

func NewSingletonTransactor(address common.Address, transactor bind.ContractTransactor) (*SingletonTransactor, error)

NewSingletonTransactor creates a new write-only instance of Singleton, bound to a specific deployed contract.

type SingletonTransactorRaw 

type SingletonTransactorRaw struct {
	Contract *SingletonTransactor // Generic write-only contract binding to access the raw methods on
}

SingletonTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*SingletonTransactorRaw) Transact 

func (_Singleton *SingletonTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*SingletonTransactorRaw) Transfer 

func (_Singleton *SingletonTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type SingletonTransactorSession 

type SingletonTransactorSession struct {
	Contract     *SingletonTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts    // Transaction auth options to use throughout this session
}

SingletonTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

type StorageAccessible 

type StorageAccessible struct {
	StorageAccessibleCaller     // Read-only binding to the contract
	StorageAccessibleTransactor // Write-only binding to the contract
	StorageAccessibleFilterer   // Log filterer for contract events
}

StorageAccessible is an auto generated Go binding around an Ethereum contract.

func DeployStorageAccessible 

func DeployStorageAccessible(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *StorageAccessible, error)

DeployStorageAccessible deploys a new Ethereum contract, binding an instance of StorageAccessible to it.

func NewStorageAccessible 

func NewStorageAccessible(address common.Address, backend bind.ContractBackend) (*StorageAccessible, error)

NewStorageAccessible creates a new instance of StorageAccessible, bound to a specific deployed contract.

type StorageAccessibleCaller 

type StorageAccessibleCaller struct {
	// contains filtered or unexported fields
}

StorageAccessibleCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewStorageAccessibleCaller 

func NewStorageAccessibleCaller(address common.Address, caller bind.ContractCaller) (*StorageAccessibleCaller, error)

NewStorageAccessibleCaller creates a new read-only instance of StorageAccessible, bound to a specific deployed contract.

func (*StorageAccessibleCaller) GetStorageAt 

func (_StorageAccessible *StorageAccessibleCaller) GetStorageAt(opts *bind.CallOpts, offset *big.Int, length *big.Int) ([]byte, error)

GetStorageAt is a free data retrieval call binding the contract method 0x5624b25b.

Solidity: function getStorageAt(uint256 offset, uint256 length) view returns(bytes)

type StorageAccessibleCallerRaw 

type StorageAccessibleCallerRaw struct {
	Contract *StorageAccessibleCaller // Generic read-only contract binding to access the raw methods on
}

StorageAccessibleCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*StorageAccessibleCallerRaw) Call 

func (_StorageAccessible *StorageAccessibleCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type StorageAccessibleCallerSession 

type StorageAccessibleCallerSession struct {
	Contract *StorageAccessibleCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts            // Call options to use throughout this session
}

StorageAccessibleCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*StorageAccessibleCallerSession) GetStorageAt 

func (_StorageAccessible *StorageAccessibleCallerSession) GetStorageAt(offset *big.Int, length *big.Int) ([]byte, error)

GetStorageAt is a free data retrieval call binding the contract method 0x5624b25b.

Solidity: function getStorageAt(uint256 offset, uint256 length) view returns(bytes)

type StorageAccessibleFilterer 

type StorageAccessibleFilterer struct {
	// contains filtered or unexported fields
}

StorageAccessibleFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewStorageAccessibleFilterer 

func NewStorageAccessibleFilterer(address common.Address, filterer bind.ContractFilterer) (*StorageAccessibleFilterer, error)

NewStorageAccessibleFilterer creates a new log filterer instance of StorageAccessible, bound to a specific deployed contract.

type StorageAccessibleRaw 

type StorageAccessibleRaw struct {
	Contract *StorageAccessible // Generic contract binding to access the raw methods on
}

StorageAccessibleRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*StorageAccessibleRaw) Call 

func (_StorageAccessible *StorageAccessibleRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*StorageAccessibleRaw) Transact 

func (_StorageAccessible *StorageAccessibleRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*StorageAccessibleRaw) Transfer 

func (_StorageAccessible *StorageAccessibleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type StorageAccessibleSession 

type StorageAccessibleSession struct {
	Contract     *StorageAccessible // 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
}

StorageAccessibleSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*StorageAccessibleSession) GetStorageAt 

func (_StorageAccessible *StorageAccessibleSession) GetStorageAt(offset *big.Int, length *big.Int) ([]byte, error)

GetStorageAt is a free data retrieval call binding the contract method 0x5624b25b.

Solidity: function getStorageAt(uint256 offset, uint256 length) view returns(bytes)

func (*StorageAccessibleSession) SimulateDelegatecall 

func (_StorageAccessible *StorageAccessibleSession) SimulateDelegatecall(targetContract common.Address, calldataPayload []byte) (*types.Transaction, error)

SimulateDelegatecall is a paid mutator transaction binding the contract method 0xf84436bd.

Solidity: function simulateDelegatecall(address targetContract, bytes calldataPayload) returns(bytes)

func (*StorageAccessibleSession) SimulateDelegatecallInternal 

func (_StorageAccessible *StorageAccessibleSession) SimulateDelegatecallInternal(targetContract common.Address, calldataPayload []byte) (*types.Transaction, error)

SimulateDelegatecallInternal is a paid mutator transaction binding the contract method 0x43218e19.

Solidity: function simulateDelegatecallInternal(address targetContract, bytes calldataPayload) returns(bytes)

type StorageAccessibleTransactor 

type StorageAccessibleTransactor struct {
	// contains filtered or unexported fields
}

StorageAccessibleTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewStorageAccessibleTransactor 

func NewStorageAccessibleTransactor(address common.Address, transactor bind.ContractTransactor) (*StorageAccessibleTransactor, error)

NewStorageAccessibleTransactor creates a new write-only instance of StorageAccessible, bound to a specific deployed contract.

func (*StorageAccessibleTransactor) SimulateDelegatecall 

func (_StorageAccessible *StorageAccessibleTransactor) SimulateDelegatecall(opts *bind.TransactOpts, targetContract common.Address, calldataPayload []byte) (*types.Transaction, error)

SimulateDelegatecall is a paid mutator transaction binding the contract method 0xf84436bd.

Solidity: function simulateDelegatecall(address targetContract, bytes calldataPayload) returns(bytes)

func (*StorageAccessibleTransactor) SimulateDelegatecallInternal 

func (_StorageAccessible *StorageAccessibleTransactor) SimulateDelegatecallInternal(opts *bind.TransactOpts, targetContract common.Address, calldataPayload []byte) (*types.Transaction, error)

SimulateDelegatecallInternal is a paid mutator transaction binding the contract method 0x43218e19.

Solidity: function simulateDelegatecallInternal(address targetContract, bytes calldataPayload) returns(bytes)

type StorageAccessibleTransactorRaw 

type StorageAccessibleTransactorRaw struct {
	Contract *StorageAccessibleTransactor // Generic write-only contract binding to access the raw methods on
}

StorageAccessibleTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*StorageAccessibleTransactorRaw) Transact 

func (_StorageAccessible *StorageAccessibleTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*StorageAccessibleTransactorRaw) Transfer 

func (_StorageAccessible *StorageAccessibleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type StorageAccessibleTransactorSession 

type StorageAccessibleTransactorSession struct {
	Contract     *StorageAccessibleTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts            // Transaction auth options to use throughout this session
}

StorageAccessibleTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*StorageAccessibleTransactorSession) SimulateDelegatecall 

func (_StorageAccessible *StorageAccessibleTransactorSession) SimulateDelegatecall(targetContract common.Address, calldataPayload []byte) (*types.Transaction, error)

SimulateDelegatecall is a paid mutator transaction binding the contract method 0xf84436bd.

Solidity: function simulateDelegatecall(address targetContract, bytes calldataPayload) returns(bytes)

func (*StorageAccessibleTransactorSession) SimulateDelegatecallInternal 

func (_StorageAccessible *StorageAccessibleTransactorSession) SimulateDelegatecallInternal(targetContract common.Address, calldataPayload []byte) (*types.Transaction, error)

SimulateDelegatecallInternal is a paid mutator transaction binding the contract method 0x43218e19.

Solidity: function simulateDelegatecallInternal(address targetContract, bytes calldataPayload) returns(bytes)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.