contracts

package
v1.9.7-0...-ba03429 Latest Latest
Warning

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

 Go to latest Published: Jan 30, 2025 License: LGPL-3.0 Imports: 10 Imported by: 0

Documentation

Index

Constants

View Source 
const KeyBroadcastContractABI = "" /* 1077-byte string literal not displayed */

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

View Source 
const KeyperSetABI = "" /* 3202-byte string literal not displayed */

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

View Source 
const KeyperSetManagerABI = "" /* 7074-byte string literal not displayed */

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

View Source 
const SequencerABI = "" /* 1751-byte string literal not displayed */

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

Variables

View Source 
var KeyBroadcastContractBin = "" /* 3392-byte string literal not displayed */

KeyBroadcastContractBin is the compiled bytecode used for deploying new contracts.

View Source 
var KeyperSetBin = "" /* 3754-byte string literal not displayed */

KeyperSetBin is the compiled bytecode used for deploying new contracts.

View Source 
var KeyperSetManagerBin = "" /* 7232-byte string literal not displayed */

KeyperSetManagerBin is the compiled bytecode used for deploying new contracts.

View Source 
var SequencerBin = "" /* 2270-byte string literal not displayed */

SequencerBin is the compiled bytecode used for deploying new contracts.

Functions

This section is empty.

Types

type KeyBroadcastContract 

type KeyBroadcastContract struct {
	KeyBroadcastContractCaller     // Read-only binding to the contract
	KeyBroadcastContractTransactor // Write-only binding to the contract
	KeyBroadcastContractFilterer   // Log filterer for contract events
}

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

func DeployKeyBroadcastContract 

func DeployKeyBroadcastContract(auth *bind.TransactOpts, backend bind.ContractBackend, keyperSetManagerAddress libcommon.Address) (libcommon.Address, types.Transaction, *KeyBroadcastContract, error)

DeployKeyBroadcastContract deploys a new Ethereum contract, binding an instance of KeyBroadcastContract to it.

func NewKeyBroadcastContract 

func NewKeyBroadcastContract(address libcommon.Address, backend bind.ContractBackend) (*KeyBroadcastContract, error)

NewKeyBroadcastContract creates a new instance of KeyBroadcastContract, bound to a specific deployed contract.

type KeyBroadcastContractBroadcastEonKeyParams 

type KeyBroadcastContractBroadcastEonKeyParams struct {
	Param_eon uint64
	Param_key []byte
}

KeyBroadcastContractBroadcastEonKeyParams is an auto generated read-only Go binding of transcaction calldata params

func ParseKeyBroadcastContractBroadcastEonKeyParams 

func ParseKeyBroadcastContractBroadcastEonKeyParams(calldata []byte) (*KeyBroadcastContractBroadcastEonKeyParams, error)

Parse BroadcastEonKey method from calldata of a transaction

Solidity: function broadcastEonKey(uint64 eon, bytes key) returns()

type KeyBroadcastContractCaller 

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

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

func NewKeyBroadcastContractCaller 

func NewKeyBroadcastContractCaller(address libcommon.Address, caller bind.ContractCaller) (*KeyBroadcastContractCaller, error)

NewKeyBroadcastContractCaller creates a new read-only instance of KeyBroadcastContract, bound to a specific deployed contract.

func (*KeyBroadcastContractCaller) GetEonKey 

func (_KeyBroadcastContract *KeyBroadcastContractCaller) GetEonKey(opts *bind.CallOpts, eon uint64) ([]byte, error)

GetEonKey is a free data retrieval call binding the contract method 0x8a0b8b28.

Solidity: function getEonKey(uint64 eon) view returns(bytes)

type KeyBroadcastContractCallerRaw 

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

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

func (*KeyBroadcastContractCallerRaw) Call 

func (_KeyBroadcastContract *KeyBroadcastContractCallerRaw) 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 KeyBroadcastContractCallerSession 

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

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

func (*KeyBroadcastContractCallerSession) GetEonKey 

func (_KeyBroadcastContract *KeyBroadcastContractCallerSession) GetEonKey(eon uint64) ([]byte, error)

GetEonKey is a free data retrieval call binding the contract method 0x8a0b8b28.

Solidity: function getEonKey(uint64 eon) view returns(bytes)

type KeyBroadcastContractEonKeyBroadcast 

type KeyBroadcastContractEonKeyBroadcast struct {
	Eon uint64
	Key []byte
	Raw types.Log // Blockchain specific contextual infos
}

KeyBroadcastContractEonKeyBroadcast represents a EonKeyBroadcast event raised by the KeyBroadcastContract contract.

type KeyBroadcastContractEonKeyBroadcastIterator 

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

KeyBroadcastContractEonKeyBroadcastIterator is returned from FilterEonKeyBroadcast and is used to iterate over the raw logs and unpacked data for EonKeyBroadcast events raised by the KeyBroadcastContract contract.

func (*KeyBroadcastContractEonKeyBroadcastIterator) Close 

func (it *KeyBroadcastContractEonKeyBroadcastIterator) Close() error

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

func (*KeyBroadcastContractEonKeyBroadcastIterator) Error 

func (it *KeyBroadcastContractEonKeyBroadcastIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*KeyBroadcastContractEonKeyBroadcastIterator) Next 

func (it *KeyBroadcastContractEonKeyBroadcastIterator) 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 KeyBroadcastContractFilterer 

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

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

func NewKeyBroadcastContractFilterer 

func NewKeyBroadcastContractFilterer(address libcommon.Address, filterer bind.ContractFilterer) (*KeyBroadcastContractFilterer, error)

NewKeyBroadcastContractFilterer creates a new log filterer instance of KeyBroadcastContract, bound to a specific deployed contract.

func (*KeyBroadcastContractFilterer) EonKeyBroadcastEventID 

func (_KeyBroadcastContract *KeyBroadcastContractFilterer) EonKeyBroadcastEventID() libcommon.Hash

func (*KeyBroadcastContractFilterer) FilterEonKeyBroadcast 

func (_KeyBroadcastContract *KeyBroadcastContractFilterer) FilterEonKeyBroadcast(opts *bind.FilterOpts) (*KeyBroadcastContractEonKeyBroadcastIterator, error)

FilterEonKeyBroadcast is a free log retrieval operation binding the contract event 0xf0dbcf46bf98296dd97ce9cb1ef117ac6fd1b2f126741125433174d56dad3768.

Solidity: event EonKeyBroadcast(uint64 eon, bytes key)

func (*KeyBroadcastContractFilterer) ParseEonKeyBroadcast 

func (_KeyBroadcastContract *KeyBroadcastContractFilterer) ParseEonKeyBroadcast(log types.Log) (*KeyBroadcastContractEonKeyBroadcast, error)

ParseEonKeyBroadcast is a log parse operation binding the contract event 0xf0dbcf46bf98296dd97ce9cb1ef117ac6fd1b2f126741125433174d56dad3768.

Solidity: event EonKeyBroadcast(uint64 eon, bytes key)

func (*KeyBroadcastContractFilterer) WatchEonKeyBroadcast 

func (_KeyBroadcastContract *KeyBroadcastContractFilterer) WatchEonKeyBroadcast(opts *bind.WatchOpts, sink chan<- *KeyBroadcastContractEonKeyBroadcast) (event.Subscription, error)

WatchEonKeyBroadcast is a free log subscription operation binding the contract event 0xf0dbcf46bf98296dd97ce9cb1ef117ac6fd1b2f126741125433174d56dad3768.

Solidity: event EonKeyBroadcast(uint64 eon, bytes key)

type KeyBroadcastContractRaw 

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

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

func (*KeyBroadcastContractRaw) Call 

func (_KeyBroadcastContract *KeyBroadcastContractRaw) 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 (*KeyBroadcastContractRaw) Transact 

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

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

func (*KeyBroadcastContractRaw) Transfer 

func (_KeyBroadcastContract *KeyBroadcastContractRaw) 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 KeyBroadcastContractSession 

type KeyBroadcastContractSession struct {
	Contract     *KeyBroadcastContract // 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
}

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

func (*KeyBroadcastContractSession) BroadcastEonKey 

func (_KeyBroadcastContract *KeyBroadcastContractSession) BroadcastEonKey(eon uint64, key []byte) (types.Transaction, error)

BroadcastEonKey is a paid mutator transaction binding the contract method 0xdaade8e8.

Solidity: function broadcastEonKey(uint64 eon, bytes key) returns()

func (*KeyBroadcastContractSession) GetEonKey 

func (_KeyBroadcastContract *KeyBroadcastContractSession) GetEonKey(eon uint64) ([]byte, error)

GetEonKey is a free data retrieval call binding the contract method 0x8a0b8b28.

Solidity: function getEonKey(uint64 eon) view returns(bytes)

type KeyBroadcastContractTransactor 

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

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

func NewKeyBroadcastContractTransactor 

func NewKeyBroadcastContractTransactor(address libcommon.Address, transactor bind.ContractTransactor) (*KeyBroadcastContractTransactor, error)

NewKeyBroadcastContractTransactor creates a new write-only instance of KeyBroadcastContract, bound to a specific deployed contract.

func (*KeyBroadcastContractTransactor) BroadcastEonKey 

func (_KeyBroadcastContract *KeyBroadcastContractTransactor) BroadcastEonKey(opts *bind.TransactOpts, eon uint64, key []byte) (types.Transaction, error)

BroadcastEonKey is a paid mutator transaction binding the contract method 0xdaade8e8.

Solidity: function broadcastEonKey(uint64 eon, bytes key) returns()

type KeyBroadcastContractTransactorRaw 

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

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

func (*KeyBroadcastContractTransactorRaw) Transact 

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

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

func (*KeyBroadcastContractTransactorRaw) Transfer 

func (_KeyBroadcastContract *KeyBroadcastContractTransactorRaw) 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 KeyBroadcastContractTransactorSession 

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

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

func (*KeyBroadcastContractTransactorSession) BroadcastEonKey 

func (_KeyBroadcastContract *KeyBroadcastContractTransactorSession) BroadcastEonKey(eon uint64, key []byte) (types.Transaction, error)

BroadcastEonKey is a paid mutator transaction binding the contract method 0xdaade8e8.

Solidity: function broadcastEonKey(uint64 eon, bytes key) returns()

type KeyperSet 

type KeyperSet struct {
	KeyperSetCaller     // Read-only binding to the contract
	KeyperSetTransactor // Write-only binding to the contract
	KeyperSetFilterer   // Log filterer for contract events
}

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

func DeployKeyperSet 

func DeployKeyperSet(auth *bind.TransactOpts, backend bind.ContractBackend) (libcommon.Address, types.Transaction, *KeyperSet, error)

DeployKeyperSet deploys a new Ethereum contract, binding an instance of KeyperSet to it.

func NewKeyperSet 

func NewKeyperSet(address libcommon.Address, backend bind.ContractBackend) (*KeyperSet, error)

NewKeyperSet creates a new instance of KeyperSet, bound to a specific deployed contract.

type KeyperSetAddMembersParams 

type KeyperSetAddMembersParams struct {
	Param_newMembers []libcommon.Address
}

KeyperSetAddMembersParams is an auto generated read-only Go binding of transcaction calldata params

func ParseKeyperSetAddMembersParams 

func ParseKeyperSetAddMembersParams(calldata []byte) (*KeyperSetAddMembersParams, error)

Parse AddMembers method from calldata of a transaction

Solidity: function addMembers(address[] newMembers) returns()

type KeyperSetCaller 

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

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

func NewKeyperSetCaller 

func NewKeyperSetCaller(address libcommon.Address, caller bind.ContractCaller) (*KeyperSetCaller, error)

NewKeyperSetCaller creates a new read-only instance of KeyperSet, bound to a specific deployed contract.

func (*KeyperSetCaller) GetMember 

func (_KeyperSet *KeyperSetCaller) GetMember(opts *bind.CallOpts, index uint64) (libcommon.Address, error)

GetMember is a free data retrieval call binding the contract method 0x2e8e6cad.

Solidity: function getMember(uint64 index) view returns(address)

func (*KeyperSetCaller) GetMembers 

func (_KeyperSet *KeyperSetCaller) GetMembers(opts *bind.CallOpts) ([]libcommon.Address, error)

GetMembers is a free data retrieval call binding the contract method 0x9eab5253.

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

func (*KeyperSetCaller) GetNumMembers 

func (_KeyperSet *KeyperSetCaller) GetNumMembers(opts *bind.CallOpts) (uint64, error)

GetNumMembers is a free data retrieval call binding the contract method 0x17d5430a.

Solidity: function getNumMembers() view returns(uint64)

func (*KeyperSetCaller) GetPublisher 

func (_KeyperSet *KeyperSetCaller) GetPublisher(opts *bind.CallOpts) (libcommon.Address, error)

GetPublisher is a free data retrieval call binding the contract method 0xdbf4ab4e.

Solidity: function getPublisher() view returns(address)

func (*KeyperSetCaller) GetThreshold 

func (_KeyperSet *KeyperSetCaller) GetThreshold(opts *bind.CallOpts) (uint64, error)

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

Solidity: function getThreshold() view returns(uint64)

func (*KeyperSetCaller) IsAllowedToBroadcastEonKey 

func (_KeyperSet *KeyperSetCaller) IsAllowedToBroadcastEonKey(opts *bind.CallOpts, a libcommon.Address) (bool, error)

IsAllowedToBroadcastEonKey is a free data retrieval call binding the contract method 0xcde1532d.

Solidity: function isAllowedToBroadcastEonKey(address a) view returns(bool)

func (*KeyperSetCaller) IsFinalized 

func (_KeyperSet *KeyperSetCaller) IsFinalized(opts *bind.CallOpts) (bool, error)

IsFinalized is a free data retrieval call binding the contract method 0x8d4e4083.

Solidity: function isFinalized() view returns(bool)

func (*KeyperSetCaller) Owner 

func (_KeyperSet *KeyperSetCaller) Owner(opts *bind.CallOpts) (libcommon.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() view returns(address)

type KeyperSetCallerRaw 

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

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

func (*KeyperSetCallerRaw) Call 

func (_KeyperSet *KeyperSetCallerRaw) 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 KeyperSetCallerSession 

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

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

func (*KeyperSetCallerSession) GetMember 

func (_KeyperSet *KeyperSetCallerSession) GetMember(index uint64) (libcommon.Address, error)

GetMember is a free data retrieval call binding the contract method 0x2e8e6cad.

Solidity: function getMember(uint64 index) view returns(address)

func (*KeyperSetCallerSession) GetMembers 

func (_KeyperSet *KeyperSetCallerSession) GetMembers() ([]libcommon.Address, error)

GetMembers is a free data retrieval call binding the contract method 0x9eab5253.

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

func (*KeyperSetCallerSession) GetNumMembers 

func (_KeyperSet *KeyperSetCallerSession) GetNumMembers() (uint64, error)

GetNumMembers is a free data retrieval call binding the contract method 0x17d5430a.

Solidity: function getNumMembers() view returns(uint64)

func (*KeyperSetCallerSession) GetPublisher 

func (_KeyperSet *KeyperSetCallerSession) GetPublisher() (libcommon.Address, error)

GetPublisher is a free data retrieval call binding the contract method 0xdbf4ab4e.

Solidity: function getPublisher() view returns(address)

func (*KeyperSetCallerSession) GetThreshold 

func (_KeyperSet *KeyperSetCallerSession) GetThreshold() (uint64, error)

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

Solidity: function getThreshold() view returns(uint64)

func (*KeyperSetCallerSession) IsAllowedToBroadcastEonKey 

func (_KeyperSet *KeyperSetCallerSession) IsAllowedToBroadcastEonKey(a libcommon.Address) (bool, error)

IsAllowedToBroadcastEonKey is a free data retrieval call binding the contract method 0xcde1532d.

Solidity: function isAllowedToBroadcastEonKey(address a) view returns(bool)

func (*KeyperSetCallerSession) IsFinalized 

func (_KeyperSet *KeyperSetCallerSession) IsFinalized() (bool, error)

IsFinalized is a free data retrieval call binding the contract method 0x8d4e4083.

Solidity: function isFinalized() view returns(bool)

func (*KeyperSetCallerSession) Owner 

func (_KeyperSet *KeyperSetCallerSession) Owner() (libcommon.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() view returns(address)

type KeyperSetFilterer 

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

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

func NewKeyperSetFilterer 

func NewKeyperSetFilterer(address libcommon.Address, filterer bind.ContractFilterer) (*KeyperSetFilterer, error)

NewKeyperSetFilterer creates a new log filterer instance of KeyperSet, bound to a specific deployed contract.

func (*KeyperSetFilterer) FilterOwnershipTransferred 

func (_KeyperSet *KeyperSetFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []libcommon.Address, newOwner []libcommon.Address) (*KeyperSetOwnershipTransferredIterator, error)

FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)

func (*KeyperSetFilterer) OwnershipTransferredEventID 

func (_KeyperSet *KeyperSetFilterer) OwnershipTransferredEventID() libcommon.Hash

func (*KeyperSetFilterer) ParseOwnershipTransferred 

func (_KeyperSet *KeyperSetFilterer) ParseOwnershipTransferred(log types.Log) (*KeyperSetOwnershipTransferred, error)

ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)

func (*KeyperSetFilterer) WatchOwnershipTransferred 

func (_KeyperSet *KeyperSetFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *KeyperSetOwnershipTransferred, previousOwner []libcommon.Address, newOwner []libcommon.Address) (event.Subscription, error)

WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)

type KeyperSetManager 

type KeyperSetManager struct {
	KeyperSetManagerCaller     // Read-only binding to the contract
	KeyperSetManagerTransactor // Write-only binding to the contract
	KeyperSetManagerFilterer   // Log filterer for contract events
}

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

func DeployKeyperSetManager 

func DeployKeyperSetManager(auth *bind.TransactOpts, backend bind.ContractBackend, initializer libcommon.Address) (libcommon.Address, types.Transaction, *KeyperSetManager, error)

DeployKeyperSetManager deploys a new Ethereum contract, binding an instance of KeyperSetManager to it.

func NewKeyperSetManager 

func NewKeyperSetManager(address libcommon.Address, backend bind.ContractBackend) (*KeyperSetManager, error)

NewKeyperSetManager creates a new instance of KeyperSetManager, bound to a specific deployed contract.

type KeyperSetManagerAddKeyperSetParams 

type KeyperSetManagerAddKeyperSetParams struct {
	Param_activationBlock   uint64
	Param_keyperSetContract libcommon.Address
}

KeyperSetManagerAddKeyperSetParams is an auto generated read-only Go binding of transcaction calldata params

func ParseKeyperSetManagerAddKeyperSetParams 

func ParseKeyperSetManagerAddKeyperSetParams(calldata []byte) (*KeyperSetManagerAddKeyperSetParams, error)

Parse AddKeyperSet method from calldata of a transaction

Solidity: function addKeyperSet(uint64 activationBlock, address keyperSetContract) returns()

type KeyperSetManagerCaller 

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

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

func NewKeyperSetManagerCaller 

func NewKeyperSetManagerCaller(address libcommon.Address, caller bind.ContractCaller) (*KeyperSetManagerCaller, error)

NewKeyperSetManagerCaller creates a new read-only instance of KeyperSetManager, bound to a specific deployed contract.

func (*KeyperSetManagerCaller) DEFAULTADMINROLE 

func (_KeyperSetManager *KeyperSetManagerCaller) DEFAULTADMINROLE(opts *bind.CallOpts) ([32]byte, error)

DEFAULTADMINROLE is a free data retrieval call binding the contract method 0xa217fddf.

Solidity: function DEFAULT_ADMIN_ROLE() view returns(bytes32)

func (*KeyperSetManagerCaller) GetKeyperSetActivationBlock 

func (_KeyperSetManager *KeyperSetManagerCaller) GetKeyperSetActivationBlock(opts *bind.CallOpts, index uint64) (uint64, error)

GetKeyperSetActivationBlock is a free data retrieval call binding the contract method 0x636df979.

Solidity: function getKeyperSetActivationBlock(uint64 index) view returns(uint64)

func (*KeyperSetManagerCaller) GetKeyperSetAddress 

func (_KeyperSetManager *KeyperSetManagerCaller) GetKeyperSetAddress(opts *bind.CallOpts, index uint64) (libcommon.Address, error)

GetKeyperSetAddress is a free data retrieval call binding the contract method 0xf90f3bed.

Solidity: function getKeyperSetAddress(uint64 index) view returns(address)

func (*KeyperSetManagerCaller) GetKeyperSetIndexByBlock 

func (_KeyperSetManager *KeyperSetManagerCaller) GetKeyperSetIndexByBlock(opts *bind.CallOpts, blockNumber uint64) (uint64, error)

GetKeyperSetIndexByBlock is a free data retrieval call binding the contract method 0x035cef15.

Solidity: function getKeyperSetIndexByBlock(uint64 blockNumber) view returns(uint64)

func (*KeyperSetManagerCaller) GetNumKeyperSets 

func (_KeyperSetManager *KeyperSetManagerCaller) GetNumKeyperSets(opts *bind.CallOpts) (uint64, error)

GetNumKeyperSets is a free data retrieval call binding the contract method 0xf2e6100a.

Solidity: function getNumKeyperSets() view returns(uint64)

func (*KeyperSetManagerCaller) GetRoleAdmin 

func (_KeyperSetManager *KeyperSetManagerCaller) GetRoleAdmin(opts *bind.CallOpts, role [32]byte) ([32]byte, error)

GetRoleAdmin is a free data retrieval call binding the contract method 0x248a9ca3.

Solidity: function getRoleAdmin(bytes32 role) view returns(bytes32)

func (*KeyperSetManagerCaller) HasRole 

func (_KeyperSetManager *KeyperSetManagerCaller) HasRole(opts *bind.CallOpts, role [32]byte, account libcommon.Address) (bool, error)

HasRole is a free data retrieval call binding the contract method 0x91d14854.

Solidity: function hasRole(bytes32 role, address account) view returns(bool)

func (*KeyperSetManagerCaller) Initializer 

func (_KeyperSetManager *KeyperSetManagerCaller) Initializer(opts *bind.CallOpts) (libcommon.Address, error)

Initializer is a free data retrieval call binding the contract method 0x9ce110d7.

Solidity: function initializer() view returns(address)

func (*KeyperSetManagerCaller) PAUSERROLE 

func (_KeyperSetManager *KeyperSetManagerCaller) PAUSERROLE(opts *bind.CallOpts) ([32]byte, error)

PAUSERROLE is a free data retrieval call binding the contract method 0xe63ab1e9.

Solidity: function PAUSER_ROLE() view returns(bytes32)

func (*KeyperSetManagerCaller) Paused 

func (_KeyperSetManager *KeyperSetManagerCaller) Paused(opts *bind.CallOpts) (bool, error)

Paused is a free data retrieval call binding the contract method 0x5c975abb.

Solidity: function paused() view returns(bool)

func (*KeyperSetManagerCaller) SupportsInterface 

func (_KeyperSetManager *KeyperSetManagerCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error)

SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.

Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)

type KeyperSetManagerCallerRaw 

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

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

func (*KeyperSetManagerCallerRaw) Call 

func (_KeyperSetManager *KeyperSetManagerCallerRaw) 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 KeyperSetManagerCallerSession 

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

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

func (*KeyperSetManagerCallerSession) DEFAULTADMINROLE 

func (_KeyperSetManager *KeyperSetManagerCallerSession) DEFAULTADMINROLE() ([32]byte, error)

DEFAULTADMINROLE is a free data retrieval call binding the contract method 0xa217fddf.

Solidity: function DEFAULT_ADMIN_ROLE() view returns(bytes32)

func (*KeyperSetManagerCallerSession) GetKeyperSetActivationBlock 

func (_KeyperSetManager *KeyperSetManagerCallerSession) GetKeyperSetActivationBlock(index uint64) (uint64, error)

GetKeyperSetActivationBlock is a free data retrieval call binding the contract method 0x636df979.

Solidity: function getKeyperSetActivationBlock(uint64 index) view returns(uint64)

func (*KeyperSetManagerCallerSession) GetKeyperSetAddress 

func (_KeyperSetManager *KeyperSetManagerCallerSession) GetKeyperSetAddress(index uint64) (libcommon.Address, error)

GetKeyperSetAddress is a free data retrieval call binding the contract method 0xf90f3bed.

Solidity: function getKeyperSetAddress(uint64 index) view returns(address)

func (*KeyperSetManagerCallerSession) GetKeyperSetIndexByBlock 

func (_KeyperSetManager *KeyperSetManagerCallerSession) GetKeyperSetIndexByBlock(blockNumber uint64) (uint64, error)

GetKeyperSetIndexByBlock is a free data retrieval call binding the contract method 0x035cef15.

Solidity: function getKeyperSetIndexByBlock(uint64 blockNumber) view returns(uint64)

func (*KeyperSetManagerCallerSession) GetNumKeyperSets 

func (_KeyperSetManager *KeyperSetManagerCallerSession) GetNumKeyperSets() (uint64, error)

GetNumKeyperSets is a free data retrieval call binding the contract method 0xf2e6100a.

Solidity: function getNumKeyperSets() view returns(uint64)

func (*KeyperSetManagerCallerSession) GetRoleAdmin 

func (_KeyperSetManager *KeyperSetManagerCallerSession) GetRoleAdmin(role [32]byte) ([32]byte, error)

GetRoleAdmin is a free data retrieval call binding the contract method 0x248a9ca3.

Solidity: function getRoleAdmin(bytes32 role) view returns(bytes32)

func (*KeyperSetManagerCallerSession) HasRole 

func (_KeyperSetManager *KeyperSetManagerCallerSession) HasRole(role [32]byte, account libcommon.Address) (bool, error)

HasRole is a free data retrieval call binding the contract method 0x91d14854.

Solidity: function hasRole(bytes32 role, address account) view returns(bool)

func (*KeyperSetManagerCallerSession) Initializer 

func (_KeyperSetManager *KeyperSetManagerCallerSession) Initializer() (libcommon.Address, error)

Initializer is a free data retrieval call binding the contract method 0x9ce110d7.

Solidity: function initializer() view returns(address)

func (*KeyperSetManagerCallerSession) PAUSERROLE 

func (_KeyperSetManager *KeyperSetManagerCallerSession) PAUSERROLE() ([32]byte, error)

PAUSERROLE is a free data retrieval call binding the contract method 0xe63ab1e9.

Solidity: function PAUSER_ROLE() view returns(bytes32)

func (*KeyperSetManagerCallerSession) Paused 

func (_KeyperSetManager *KeyperSetManagerCallerSession) Paused() (bool, error)

Paused is a free data retrieval call binding the contract method 0x5c975abb.

Solidity: function paused() view returns(bool)

func (*KeyperSetManagerCallerSession) SupportsInterface 

func (_KeyperSetManager *KeyperSetManagerCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.

Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)

type KeyperSetManagerFilterer 

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

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

func NewKeyperSetManagerFilterer 

func NewKeyperSetManagerFilterer(address libcommon.Address, filterer bind.ContractFilterer) (*KeyperSetManagerFilterer, error)

NewKeyperSetManagerFilterer creates a new log filterer instance of KeyperSetManager, bound to a specific deployed contract.

func (*KeyperSetManagerFilterer) FilterKeyperSetAdded 

func (_KeyperSetManager *KeyperSetManagerFilterer) FilterKeyperSetAdded(opts *bind.FilterOpts) (*KeyperSetManagerKeyperSetAddedIterator, error)

FilterKeyperSetAdded is a free log retrieval operation binding the contract event 0xa940387dac06ebd336730f1d14b21629a9d137069a9137e871f95313e1010165.

Solidity: event KeyperSetAdded(uint64 activationBlock, address keyperSetContract, address[] members, uint64 threshold, uint64 eon)

func (*KeyperSetManagerFilterer) FilterKeyperSetAdded0 

func (_KeyperSetManager *KeyperSetManagerFilterer) FilterKeyperSetAdded0(opts *bind.FilterOpts) (*KeyperSetManagerKeyperSetAdded0Iterator, error)

FilterKeyperSetAdded0 is a free log retrieval operation binding the contract event 0x6605cb866297050f9f49ae7e0b38e0e4c8178d4b176e24332bc01672818d707b.

Solidity: event KeyperSetAdded(uint64 activationSlot, address keyperSetContract)

func (*KeyperSetManagerFilterer) FilterPaused 

func (_KeyperSetManager *KeyperSetManagerFilterer) FilterPaused(opts *bind.FilterOpts) (*KeyperSetManagerPausedIterator, error)

FilterPaused is a free log retrieval operation binding the contract event 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258.

Solidity: event Paused(address account)

func (*KeyperSetManagerFilterer) FilterRoleAdminChanged 

func (_KeyperSetManager *KeyperSetManagerFilterer) FilterRoleAdminChanged(opts *bind.FilterOpts, role [][32]byte, previousAdminRole [][32]byte, newAdminRole [][32]byte) (*KeyperSetManagerRoleAdminChangedIterator, error)

FilterRoleAdminChanged is a free log retrieval operation binding the contract event 0xbd79b86ffe0ab8e8776151514217cd7cacd52c909f66475c3af44e129f0b00ff.

Solidity: event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole)

func (*KeyperSetManagerFilterer) FilterRoleGranted 

func (_KeyperSetManager *KeyperSetManagerFilterer) FilterRoleGranted(opts *bind.FilterOpts, role [][32]byte, account []libcommon.Address, sender []libcommon.Address) (*KeyperSetManagerRoleGrantedIterator, error)

FilterRoleGranted is a free log retrieval operation binding the contract event 0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d.

Solidity: event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender)

func (*KeyperSetManagerFilterer) FilterRoleRevoked 

func (_KeyperSetManager *KeyperSetManagerFilterer) FilterRoleRevoked(opts *bind.FilterOpts, role [][32]byte, account []libcommon.Address, sender []libcommon.Address) (*KeyperSetManagerRoleRevokedIterator, error)

FilterRoleRevoked is a free log retrieval operation binding the contract event 0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b.

Solidity: event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender)

func (*KeyperSetManagerFilterer) FilterUnpaused 

func (_KeyperSetManager *KeyperSetManagerFilterer) FilterUnpaused(opts *bind.FilterOpts) (*KeyperSetManagerUnpausedIterator, error)

FilterUnpaused is a free log retrieval operation binding the contract event 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa.

Solidity: event Unpaused(address account)

func (*KeyperSetManagerFilterer) KeyperSetAdded0EventID 

func (_KeyperSetManager *KeyperSetManagerFilterer) KeyperSetAdded0EventID() libcommon.Hash

func (*KeyperSetManagerFilterer) KeyperSetAddedEventID 

func (_KeyperSetManager *KeyperSetManagerFilterer) KeyperSetAddedEventID() libcommon.Hash

func (*KeyperSetManagerFilterer) ParseKeyperSetAdded 

func (_KeyperSetManager *KeyperSetManagerFilterer) ParseKeyperSetAdded(log types.Log) (*KeyperSetManagerKeyperSetAdded, error)

ParseKeyperSetAdded is a log parse operation binding the contract event 0xa940387dac06ebd336730f1d14b21629a9d137069a9137e871f95313e1010165.

Solidity: event KeyperSetAdded(uint64 activationBlock, address keyperSetContract, address[] members, uint64 threshold, uint64 eon)

func (*KeyperSetManagerFilterer) ParseKeyperSetAdded0 

func (_KeyperSetManager *KeyperSetManagerFilterer) ParseKeyperSetAdded0(log types.Log) (*KeyperSetManagerKeyperSetAdded0, error)

ParseKeyperSetAdded0 is a log parse operation binding the contract event 0x6605cb866297050f9f49ae7e0b38e0e4c8178d4b176e24332bc01672818d707b.

Solidity: event KeyperSetAdded(uint64 activationSlot, address keyperSetContract)

func (*KeyperSetManagerFilterer) ParsePaused 

func (_KeyperSetManager *KeyperSetManagerFilterer) ParsePaused(log types.Log) (*KeyperSetManagerPaused, error)

ParsePaused is a log parse operation binding the contract event 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258.

Solidity: event Paused(address account)

func (*KeyperSetManagerFilterer) ParseRoleAdminChanged 

func (_KeyperSetManager *KeyperSetManagerFilterer) ParseRoleAdminChanged(log types.Log) (*KeyperSetManagerRoleAdminChanged, error)

ParseRoleAdminChanged is a log parse operation binding the contract event 0xbd79b86ffe0ab8e8776151514217cd7cacd52c909f66475c3af44e129f0b00ff.

Solidity: event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole)

func (*KeyperSetManagerFilterer) ParseRoleGranted 

func (_KeyperSetManager *KeyperSetManagerFilterer) ParseRoleGranted(log types.Log) (*KeyperSetManagerRoleGranted, error)

ParseRoleGranted is a log parse operation binding the contract event 0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d.

Solidity: event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender)

func (*KeyperSetManagerFilterer) ParseRoleRevoked 

func (_KeyperSetManager *KeyperSetManagerFilterer) ParseRoleRevoked(log types.Log) (*KeyperSetManagerRoleRevoked, error)

ParseRoleRevoked is a log parse operation binding the contract event 0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b.

Solidity: event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender)

func (*KeyperSetManagerFilterer) ParseUnpaused 

func (_KeyperSetManager *KeyperSetManagerFilterer) ParseUnpaused(log types.Log) (*KeyperSetManagerUnpaused, error)

ParseUnpaused is a log parse operation binding the contract event 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa.

Solidity: event Unpaused(address account)

func (*KeyperSetManagerFilterer) PausedEventID 

func (_KeyperSetManager *KeyperSetManagerFilterer) PausedEventID() libcommon.Hash

func (*KeyperSetManagerFilterer) RoleAdminChangedEventID 

func (_KeyperSetManager *KeyperSetManagerFilterer) RoleAdminChangedEventID() libcommon.Hash

func (*KeyperSetManagerFilterer) RoleGrantedEventID 

func (_KeyperSetManager *KeyperSetManagerFilterer) RoleGrantedEventID() libcommon.Hash

func (*KeyperSetManagerFilterer) RoleRevokedEventID 

func (_KeyperSetManager *KeyperSetManagerFilterer) RoleRevokedEventID() libcommon.Hash

func (*KeyperSetManagerFilterer) UnpausedEventID 

func (_KeyperSetManager *KeyperSetManagerFilterer) UnpausedEventID() libcommon.Hash

func (*KeyperSetManagerFilterer) WatchKeyperSetAdded 

func (_KeyperSetManager *KeyperSetManagerFilterer) WatchKeyperSetAdded(opts *bind.WatchOpts, sink chan<- *KeyperSetManagerKeyperSetAdded) (event.Subscription, error)

WatchKeyperSetAdded is a free log subscription operation binding the contract event 0xa940387dac06ebd336730f1d14b21629a9d137069a9137e871f95313e1010165.

Solidity: event KeyperSetAdded(uint64 activationBlock, address keyperSetContract, address[] members, uint64 threshold, uint64 eon)

func (*KeyperSetManagerFilterer) WatchKeyperSetAdded0 

func (_KeyperSetManager *KeyperSetManagerFilterer) WatchKeyperSetAdded0(opts *bind.WatchOpts, sink chan<- *KeyperSetManagerKeyperSetAdded0) (event.Subscription, error)

WatchKeyperSetAdded0 is a free log subscription operation binding the contract event 0x6605cb866297050f9f49ae7e0b38e0e4c8178d4b176e24332bc01672818d707b.

Solidity: event KeyperSetAdded(uint64 activationSlot, address keyperSetContract)

func (*KeyperSetManagerFilterer) WatchPaused 

func (_KeyperSetManager *KeyperSetManagerFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *KeyperSetManagerPaused) (event.Subscription, error)

WatchPaused is a free log subscription operation binding the contract event 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258.

Solidity: event Paused(address account)

func (*KeyperSetManagerFilterer) WatchRoleAdminChanged 

func (_KeyperSetManager *KeyperSetManagerFilterer) WatchRoleAdminChanged(opts *bind.WatchOpts, sink chan<- *KeyperSetManagerRoleAdminChanged, role [][32]byte, previousAdminRole [][32]byte, newAdminRole [][32]byte) (event.Subscription, error)

WatchRoleAdminChanged is a free log subscription operation binding the contract event 0xbd79b86ffe0ab8e8776151514217cd7cacd52c909f66475c3af44e129f0b00ff.

Solidity: event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole)

func (*KeyperSetManagerFilterer) WatchRoleGranted 

func (_KeyperSetManager *KeyperSetManagerFilterer) WatchRoleGranted(opts *bind.WatchOpts, sink chan<- *KeyperSetManagerRoleGranted, role [][32]byte, account []libcommon.Address, sender []libcommon.Address) (event.Subscription, error)

WatchRoleGranted is a free log subscription operation binding the contract event 0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d.

Solidity: event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender)

func (*KeyperSetManagerFilterer) WatchRoleRevoked 

func (_KeyperSetManager *KeyperSetManagerFilterer) WatchRoleRevoked(opts *bind.WatchOpts, sink chan<- *KeyperSetManagerRoleRevoked, role [][32]byte, account []libcommon.Address, sender []libcommon.Address) (event.Subscription, error)

WatchRoleRevoked is a free log subscription operation binding the contract event 0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b.

Solidity: event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender)

func (*KeyperSetManagerFilterer) WatchUnpaused 

func (_KeyperSetManager *KeyperSetManagerFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *KeyperSetManagerUnpaused) (event.Subscription, error)

WatchUnpaused is a free log subscription operation binding the contract event 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa.

Solidity: event Unpaused(address account)

type KeyperSetManagerGrantRoleParams 

type KeyperSetManagerGrantRoleParams struct {
	Param_role    [32]byte
	Param_account libcommon.Address
}

KeyperSetManagerGrantRoleParams is an auto generated read-only Go binding of transcaction calldata params

func ParseKeyperSetManagerGrantRoleParams 

func ParseKeyperSetManagerGrantRoleParams(calldata []byte) (*KeyperSetManagerGrantRoleParams, error)

Parse GrantRole method from calldata of a transaction

Solidity: function grantRole(bytes32 role, address account) returns()

type KeyperSetManagerInitializeParams 

type KeyperSetManagerInitializeParams struct {
	Param_admin  libcommon.Address
	Param_pauser libcommon.Address
}

KeyperSetManagerInitializeParams is an auto generated read-only Go binding of transcaction calldata params

func ParseKeyperSetManagerInitializeParams 

func ParseKeyperSetManagerInitializeParams(calldata []byte) (*KeyperSetManagerInitializeParams, error)

Parse Initialize method from calldata of a transaction

Solidity: function initialize(address admin, address pauser) returns()

type KeyperSetManagerKeyperSetAdded 

type KeyperSetManagerKeyperSetAdded struct {
	ActivationBlock   uint64
	KeyperSetContract libcommon.Address
	Members           []libcommon.Address
	Threshold         uint64
	Eon               uint64
	Raw               types.Log // Blockchain specific contextual infos
}

KeyperSetManagerKeyperSetAdded represents a KeyperSetAdded event raised by the KeyperSetManager contract.

type KeyperSetManagerKeyperSetAdded0 

type KeyperSetManagerKeyperSetAdded0 struct {
	ActivationSlot    uint64
	KeyperSetContract libcommon.Address
	Raw               types.Log // Blockchain specific contextual infos
}

KeyperSetManagerKeyperSetAdded0 represents a KeyperSetAdded0 event raised by the KeyperSetManager contract.

type KeyperSetManagerKeyperSetAdded0Iterator 

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

KeyperSetManagerKeyperSetAdded0Iterator is returned from FilterKeyperSetAdded0 and is used to iterate over the raw logs and unpacked data for KeyperSetAdded0 events raised by the KeyperSetManager contract.

func (*KeyperSetManagerKeyperSetAdded0Iterator) Close 

func (it *KeyperSetManagerKeyperSetAdded0Iterator) Close() error

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

func (*KeyperSetManagerKeyperSetAdded0Iterator) Error 

func (it *KeyperSetManagerKeyperSetAdded0Iterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*KeyperSetManagerKeyperSetAdded0Iterator) Next 

func (it *KeyperSetManagerKeyperSetAdded0Iterator) 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 KeyperSetManagerKeyperSetAddedIterator 

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

KeyperSetManagerKeyperSetAddedIterator is returned from FilterKeyperSetAdded and is used to iterate over the raw logs and unpacked data for KeyperSetAdded events raised by the KeyperSetManager contract.

func (*KeyperSetManagerKeyperSetAddedIterator) Close 

func (it *KeyperSetManagerKeyperSetAddedIterator) Close() error

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

func (*KeyperSetManagerKeyperSetAddedIterator) Error 

func (it *KeyperSetManagerKeyperSetAddedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*KeyperSetManagerKeyperSetAddedIterator) Next 

func (it *KeyperSetManagerKeyperSetAddedIterator) 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 KeyperSetManagerPaused 

type KeyperSetManagerPaused struct {
	Account libcommon.Address
	Raw     types.Log // Blockchain specific contextual infos
}

KeyperSetManagerPaused represents a Paused event raised by the KeyperSetManager contract.

type KeyperSetManagerPausedIterator 

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

KeyperSetManagerPausedIterator is returned from FilterPaused and is used to iterate over the raw logs and unpacked data for Paused events raised by the KeyperSetManager contract.

func (*KeyperSetManagerPausedIterator) Close 

func (it *KeyperSetManagerPausedIterator) Close() error

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

func (*KeyperSetManagerPausedIterator) Error 

func (it *KeyperSetManagerPausedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*KeyperSetManagerPausedIterator) Next 

func (it *KeyperSetManagerPausedIterator) 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 KeyperSetManagerRaw 

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

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

func (*KeyperSetManagerRaw) Call 

func (_KeyperSetManager *KeyperSetManagerRaw) 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 (*KeyperSetManagerRaw) Transact 

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

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

func (*KeyperSetManagerRaw) Transfer 

func (_KeyperSetManager *KeyperSetManagerRaw) 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 KeyperSetManagerRenounceRoleParams 

type KeyperSetManagerRenounceRoleParams struct {
	Param_role               [32]byte
	Param_callerConfirmation libcommon.Address
}

KeyperSetManagerRenounceRoleParams is an auto generated read-only Go binding of transcaction calldata params

func ParseKeyperSetManagerRenounceRoleParams 

func ParseKeyperSetManagerRenounceRoleParams(calldata []byte) (*KeyperSetManagerRenounceRoleParams, error)

Parse RenounceRole method from calldata of a transaction

Solidity: function renounceRole(bytes32 role, address callerConfirmation) returns()

type KeyperSetManagerRevokeRoleParams 

type KeyperSetManagerRevokeRoleParams struct {
	Param_role    [32]byte
	Param_account libcommon.Address
}

KeyperSetManagerRevokeRoleParams is an auto generated read-only Go binding of transcaction calldata params

func ParseKeyperSetManagerRevokeRoleParams 

func ParseKeyperSetManagerRevokeRoleParams(calldata []byte) (*KeyperSetManagerRevokeRoleParams, error)

Parse RevokeRole method from calldata of a transaction

Solidity: function revokeRole(bytes32 role, address account) returns()

type KeyperSetManagerRoleAdminChanged 

type KeyperSetManagerRoleAdminChanged struct {
	Role              [32]byte
	PreviousAdminRole [32]byte
	NewAdminRole      [32]byte
	Raw               types.Log // Blockchain specific contextual infos
}

KeyperSetManagerRoleAdminChanged represents a RoleAdminChanged event raised by the KeyperSetManager contract.

type KeyperSetManagerRoleAdminChangedIterator 

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

KeyperSetManagerRoleAdminChangedIterator is returned from FilterRoleAdminChanged and is used to iterate over the raw logs and unpacked data for RoleAdminChanged events raised by the KeyperSetManager contract.

func (*KeyperSetManagerRoleAdminChangedIterator) Close 

func (it *KeyperSetManagerRoleAdminChangedIterator) Close() error

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

func (*KeyperSetManagerRoleAdminChangedIterator) Error 

func (it *KeyperSetManagerRoleAdminChangedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*KeyperSetManagerRoleAdminChangedIterator) Next 

func (it *KeyperSetManagerRoleAdminChangedIterator) 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 KeyperSetManagerRoleGranted 

type KeyperSetManagerRoleGranted struct {
	Role    [32]byte
	Account libcommon.Address
	Sender  libcommon.Address
	Raw     types.Log // Blockchain specific contextual infos
}

KeyperSetManagerRoleGranted represents a RoleGranted event raised by the KeyperSetManager contract.

type KeyperSetManagerRoleGrantedIterator 

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

KeyperSetManagerRoleGrantedIterator is returned from FilterRoleGranted and is used to iterate over the raw logs and unpacked data for RoleGranted events raised by the KeyperSetManager contract.

func (*KeyperSetManagerRoleGrantedIterator) Close 

func (it *KeyperSetManagerRoleGrantedIterator) Close() error

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

func (*KeyperSetManagerRoleGrantedIterator) Error 

func (it *KeyperSetManagerRoleGrantedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*KeyperSetManagerRoleGrantedIterator) Next 

func (it *KeyperSetManagerRoleGrantedIterator) 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 KeyperSetManagerRoleRevoked 

type KeyperSetManagerRoleRevoked struct {
	Role    [32]byte
	Account libcommon.Address
	Sender  libcommon.Address
	Raw     types.Log // Blockchain specific contextual infos
}

KeyperSetManagerRoleRevoked represents a RoleRevoked event raised by the KeyperSetManager contract.

type KeyperSetManagerRoleRevokedIterator 

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

KeyperSetManagerRoleRevokedIterator is returned from FilterRoleRevoked and is used to iterate over the raw logs and unpacked data for RoleRevoked events raised by the KeyperSetManager contract.

func (*KeyperSetManagerRoleRevokedIterator) Close 

func (it *KeyperSetManagerRoleRevokedIterator) Close() error

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

func (*KeyperSetManagerRoleRevokedIterator) Error 

func (it *KeyperSetManagerRoleRevokedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*KeyperSetManagerRoleRevokedIterator) Next 

func (it *KeyperSetManagerRoleRevokedIterator) 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 KeyperSetManagerSession 

type KeyperSetManagerSession struct {
	Contract     *KeyperSetManager // 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
}

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

func (*KeyperSetManagerSession) AddKeyperSet 

func (_KeyperSetManager *KeyperSetManagerSession) AddKeyperSet(activationBlock uint64, keyperSetContract libcommon.Address) (types.Transaction, error)

AddKeyperSet is a paid mutator transaction binding the contract method 0xd3877c43.

Solidity: function addKeyperSet(uint64 activationBlock, address keyperSetContract) returns()

func (*KeyperSetManagerSession) DEFAULTADMINROLE 

func (_KeyperSetManager *KeyperSetManagerSession) DEFAULTADMINROLE() ([32]byte, error)

DEFAULTADMINROLE is a free data retrieval call binding the contract method 0xa217fddf.

Solidity: function DEFAULT_ADMIN_ROLE() view returns(bytes32)

func (*KeyperSetManagerSession) GetKeyperSetActivationBlock 

func (_KeyperSetManager *KeyperSetManagerSession) GetKeyperSetActivationBlock(index uint64) (uint64, error)

GetKeyperSetActivationBlock is a free data retrieval call binding the contract method 0x636df979.

Solidity: function getKeyperSetActivationBlock(uint64 index) view returns(uint64)

func (*KeyperSetManagerSession) GetKeyperSetAddress 

func (_KeyperSetManager *KeyperSetManagerSession) GetKeyperSetAddress(index uint64) (libcommon.Address, error)

GetKeyperSetAddress is a free data retrieval call binding the contract method 0xf90f3bed.

Solidity: function getKeyperSetAddress(uint64 index) view returns(address)

func (*KeyperSetManagerSession) GetKeyperSetIndexByBlock 

func (_KeyperSetManager *KeyperSetManagerSession) GetKeyperSetIndexByBlock(blockNumber uint64) (uint64, error)

GetKeyperSetIndexByBlock is a free data retrieval call binding the contract method 0x035cef15.

Solidity: function getKeyperSetIndexByBlock(uint64 blockNumber) view returns(uint64)

func (*KeyperSetManagerSession) GetNumKeyperSets 

func (_KeyperSetManager *KeyperSetManagerSession) GetNumKeyperSets() (uint64, error)

GetNumKeyperSets is a free data retrieval call binding the contract method 0xf2e6100a.

Solidity: function getNumKeyperSets() view returns(uint64)

func (*KeyperSetManagerSession) GetRoleAdmin 

func (_KeyperSetManager *KeyperSetManagerSession) GetRoleAdmin(role [32]byte) ([32]byte, error)

GetRoleAdmin is a free data retrieval call binding the contract method 0x248a9ca3.

Solidity: function getRoleAdmin(bytes32 role) view returns(bytes32)

func (*KeyperSetManagerSession) GrantRole 

func (_KeyperSetManager *KeyperSetManagerSession) GrantRole(role [32]byte, account libcommon.Address) (types.Transaction, error)

GrantRole is a paid mutator transaction binding the contract method 0x2f2ff15d.

Solidity: function grantRole(bytes32 role, address account) returns()

func (*KeyperSetManagerSession) HasRole 

func (_KeyperSetManager *KeyperSetManagerSession) HasRole(role [32]byte, account libcommon.Address) (bool, error)

HasRole is a free data retrieval call binding the contract method 0x91d14854.

Solidity: function hasRole(bytes32 role, address account) view returns(bool)

func (*KeyperSetManagerSession) Initialize 

func (_KeyperSetManager *KeyperSetManagerSession) Initialize(admin libcommon.Address, pauser libcommon.Address) (types.Transaction, error)

Initialize is a paid mutator transaction binding the contract method 0x485cc955.

Solidity: function initialize(address admin, address pauser) returns()

func (*KeyperSetManagerSession) Initializer 

func (_KeyperSetManager *KeyperSetManagerSession) Initializer() (libcommon.Address, error)

Initializer is a free data retrieval call binding the contract method 0x9ce110d7.

Solidity: function initializer() view returns(address)

func (*KeyperSetManagerSession) PAUSERROLE 

func (_KeyperSetManager *KeyperSetManagerSession) PAUSERROLE() ([32]byte, error)

PAUSERROLE is a free data retrieval call binding the contract method 0xe63ab1e9.

Solidity: function PAUSER_ROLE() view returns(bytes32)

func (*KeyperSetManagerSession) Pause 

func (_KeyperSetManager *KeyperSetManagerSession) Pause() (types.Transaction, error)

Pause is a paid mutator transaction binding the contract method 0x8456cb59.

Solidity: function pause() returns()

func (*KeyperSetManagerSession) Paused 

func (_KeyperSetManager *KeyperSetManagerSession) Paused() (bool, error)

Paused is a free data retrieval call binding the contract method 0x5c975abb.

Solidity: function paused() view returns(bool)

func (*KeyperSetManagerSession) RenounceRole 

func (_KeyperSetManager *KeyperSetManagerSession) RenounceRole(role [32]byte, callerConfirmation libcommon.Address) (types.Transaction, error)

RenounceRole is a paid mutator transaction binding the contract method 0x36568abe.

Solidity: function renounceRole(bytes32 role, address callerConfirmation) returns()

func (*KeyperSetManagerSession) RevokeRole 

func (_KeyperSetManager *KeyperSetManagerSession) RevokeRole(role [32]byte, account libcommon.Address) (types.Transaction, error)

RevokeRole is a paid mutator transaction binding the contract method 0xd547741f.

Solidity: function revokeRole(bytes32 role, address account) returns()

func (*KeyperSetManagerSession) SupportsInterface 

func (_KeyperSetManager *KeyperSetManagerSession) SupportsInterface(interfaceId [4]byte) (bool, error)

SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.

Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool)

func (*KeyperSetManagerSession) Unpause 

func (_KeyperSetManager *KeyperSetManagerSession) Unpause() (types.Transaction, error)

Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a.

Solidity: function unpause() returns()

type KeyperSetManagerTransactor 

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

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

func NewKeyperSetManagerTransactor 

func NewKeyperSetManagerTransactor(address libcommon.Address, transactor bind.ContractTransactor) (*KeyperSetManagerTransactor, error)

NewKeyperSetManagerTransactor creates a new write-only instance of KeyperSetManager, bound to a specific deployed contract.

func (*KeyperSetManagerTransactor) AddKeyperSet 

func (_KeyperSetManager *KeyperSetManagerTransactor) AddKeyperSet(opts *bind.TransactOpts, activationBlock uint64, keyperSetContract libcommon.Address) (types.Transaction, error)

AddKeyperSet is a paid mutator transaction binding the contract method 0xd3877c43.

Solidity: function addKeyperSet(uint64 activationBlock, address keyperSetContract) returns()

func (*KeyperSetManagerTransactor) GrantRole 

func (_KeyperSetManager *KeyperSetManagerTransactor) GrantRole(opts *bind.TransactOpts, role [32]byte, account libcommon.Address) (types.Transaction, error)

GrantRole is a paid mutator transaction binding the contract method 0x2f2ff15d.

Solidity: function grantRole(bytes32 role, address account) returns()

func (*KeyperSetManagerTransactor) Initialize 

func (_KeyperSetManager *KeyperSetManagerTransactor) Initialize(opts *bind.TransactOpts, admin libcommon.Address, pauser libcommon.Address) (types.Transaction, error)

Initialize is a paid mutator transaction binding the contract method 0x485cc955.

Solidity: function initialize(address admin, address pauser) returns()

func (*KeyperSetManagerTransactor) Pause 

func (_KeyperSetManager *KeyperSetManagerTransactor) Pause(opts *bind.TransactOpts) (types.Transaction, error)

Pause is a paid mutator transaction binding the contract method 0x8456cb59.

Solidity: function pause() returns()

func (*KeyperSetManagerTransactor) RenounceRole 

func (_KeyperSetManager *KeyperSetManagerTransactor) RenounceRole(opts *bind.TransactOpts, role [32]byte, callerConfirmation libcommon.Address) (types.Transaction, error)

RenounceRole is a paid mutator transaction binding the contract method 0x36568abe.

Solidity: function renounceRole(bytes32 role, address callerConfirmation) returns()

func (*KeyperSetManagerTransactor) RevokeRole 

func (_KeyperSetManager *KeyperSetManagerTransactor) RevokeRole(opts *bind.TransactOpts, role [32]byte, account libcommon.Address) (types.Transaction, error)

RevokeRole is a paid mutator transaction binding the contract method 0xd547741f.

Solidity: function revokeRole(bytes32 role, address account) returns()

func (*KeyperSetManagerTransactor) Unpause 

func (_KeyperSetManager *KeyperSetManagerTransactor) Unpause(opts *bind.TransactOpts) (types.Transaction, error)

Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a.

Solidity: function unpause() returns()

type KeyperSetManagerTransactorRaw 

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

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

func (*KeyperSetManagerTransactorRaw) Transact 

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

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

func (*KeyperSetManagerTransactorRaw) Transfer 

func (_KeyperSetManager *KeyperSetManagerTransactorRaw) 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 KeyperSetManagerTransactorSession 

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

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

func (*KeyperSetManagerTransactorSession) AddKeyperSet 

func (_KeyperSetManager *KeyperSetManagerTransactorSession) AddKeyperSet(activationBlock uint64, keyperSetContract libcommon.Address) (types.Transaction, error)

AddKeyperSet is a paid mutator transaction binding the contract method 0xd3877c43.

Solidity: function addKeyperSet(uint64 activationBlock, address keyperSetContract) returns()

func (*KeyperSetManagerTransactorSession) GrantRole 

func (_KeyperSetManager *KeyperSetManagerTransactorSession) GrantRole(role [32]byte, account libcommon.Address) (types.Transaction, error)

GrantRole is a paid mutator transaction binding the contract method 0x2f2ff15d.

Solidity: function grantRole(bytes32 role, address account) returns()

func (*KeyperSetManagerTransactorSession) Initialize 

func (_KeyperSetManager *KeyperSetManagerTransactorSession) Initialize(admin libcommon.Address, pauser libcommon.Address) (types.Transaction, error)

Initialize is a paid mutator transaction binding the contract method 0x485cc955.

Solidity: function initialize(address admin, address pauser) returns()

func (*KeyperSetManagerTransactorSession) Pause 

func (_KeyperSetManager *KeyperSetManagerTransactorSession) Pause() (types.Transaction, error)

Pause is a paid mutator transaction binding the contract method 0x8456cb59.

Solidity: function pause() returns()

func (*KeyperSetManagerTransactorSession) RenounceRole 

func (_KeyperSetManager *KeyperSetManagerTransactorSession) RenounceRole(role [32]byte, callerConfirmation libcommon.Address) (types.Transaction, error)

RenounceRole is a paid mutator transaction binding the contract method 0x36568abe.

Solidity: function renounceRole(bytes32 role, address callerConfirmation) returns()

func (*KeyperSetManagerTransactorSession) RevokeRole 

func (_KeyperSetManager *KeyperSetManagerTransactorSession) RevokeRole(role [32]byte, account libcommon.Address) (types.Transaction, error)

RevokeRole is a paid mutator transaction binding the contract method 0xd547741f.

Solidity: function revokeRole(bytes32 role, address account) returns()

func (*KeyperSetManagerTransactorSession) Unpause 

func (_KeyperSetManager *KeyperSetManagerTransactorSession) Unpause() (types.Transaction, error)

Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a.

Solidity: function unpause() returns()

type KeyperSetManagerUnpaused 

type KeyperSetManagerUnpaused struct {
	Account libcommon.Address
	Raw     types.Log // Blockchain specific contextual infos
}

KeyperSetManagerUnpaused represents a Unpaused event raised by the KeyperSetManager contract.

type KeyperSetManagerUnpausedIterator 

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

KeyperSetManagerUnpausedIterator is returned from FilterUnpaused and is used to iterate over the raw logs and unpacked data for Unpaused events raised by the KeyperSetManager contract.

func (*KeyperSetManagerUnpausedIterator) Close 

func (it *KeyperSetManagerUnpausedIterator) Close() error

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

func (*KeyperSetManagerUnpausedIterator) Error 

func (it *KeyperSetManagerUnpausedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*KeyperSetManagerUnpausedIterator) Next 

func (it *KeyperSetManagerUnpausedIterator) 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 KeyperSetOwnershipTransferred 

type KeyperSetOwnershipTransferred struct {
	PreviousOwner libcommon.Address
	NewOwner      libcommon.Address
	Raw           types.Log // Blockchain specific contextual infos
}

KeyperSetOwnershipTransferred represents a OwnershipTransferred event raised by the KeyperSet contract.

type KeyperSetOwnershipTransferredIterator 

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

KeyperSetOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the KeyperSet contract.

func (*KeyperSetOwnershipTransferredIterator) Close 

func (it *KeyperSetOwnershipTransferredIterator) Close() error

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

func (*KeyperSetOwnershipTransferredIterator) Error 

func (it *KeyperSetOwnershipTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*KeyperSetOwnershipTransferredIterator) Next 

func (it *KeyperSetOwnershipTransferredIterator) 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 KeyperSetRaw 

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

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

func (*KeyperSetRaw) Call 

func (_KeyperSet *KeyperSetRaw) 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 (*KeyperSetRaw) Transact 

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

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

func (*KeyperSetRaw) Transfer 

func (_KeyperSet *KeyperSetRaw) 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 KeyperSetSession 

type KeyperSetSession struct {
	Contract     *KeyperSet        // 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
}

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

func (*KeyperSetSession) AddMembers 

func (_KeyperSet *KeyperSetSession) AddMembers(newMembers []libcommon.Address) (types.Transaction, error)

AddMembers is a paid mutator transaction binding the contract method 0x6f4d469b.

Solidity: function addMembers(address[] newMembers) returns()

func (*KeyperSetSession) GetMember 

func (_KeyperSet *KeyperSetSession) GetMember(index uint64) (libcommon.Address, error)

GetMember is a free data retrieval call binding the contract method 0x2e8e6cad.

Solidity: function getMember(uint64 index) view returns(address)

func (*KeyperSetSession) GetMembers 

func (_KeyperSet *KeyperSetSession) GetMembers() ([]libcommon.Address, error)

GetMembers is a free data retrieval call binding the contract method 0x9eab5253.

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

func (*KeyperSetSession) GetNumMembers 

func (_KeyperSet *KeyperSetSession) GetNumMembers() (uint64, error)

GetNumMembers is a free data retrieval call binding the contract method 0x17d5430a.

Solidity: function getNumMembers() view returns(uint64)

func (*KeyperSetSession) GetPublisher 

func (_KeyperSet *KeyperSetSession) GetPublisher() (libcommon.Address, error)

GetPublisher is a free data retrieval call binding the contract method 0xdbf4ab4e.

Solidity: function getPublisher() view returns(address)

func (*KeyperSetSession) GetThreshold 

func (_KeyperSet *KeyperSetSession) GetThreshold() (uint64, error)

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

Solidity: function getThreshold() view returns(uint64)

func (*KeyperSetSession) IsAllowedToBroadcastEonKey 

func (_KeyperSet *KeyperSetSession) IsAllowedToBroadcastEonKey(a libcommon.Address) (bool, error)

IsAllowedToBroadcastEonKey is a free data retrieval call binding the contract method 0xcde1532d.

Solidity: function isAllowedToBroadcastEonKey(address a) view returns(bool)

func (*KeyperSetSession) IsFinalized 

func (_KeyperSet *KeyperSetSession) IsFinalized() (bool, error)

IsFinalized is a free data retrieval call binding the contract method 0x8d4e4083.

Solidity: function isFinalized() view returns(bool)

func (*KeyperSetSession) Owner 

func (_KeyperSet *KeyperSetSession) Owner() (libcommon.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() view returns(address)

func (*KeyperSetSession) RenounceOwnership 

func (_KeyperSet *KeyperSetSession) RenounceOwnership() (types.Transaction, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*KeyperSetSession) SetFinalized 

func (_KeyperSet *KeyperSetSession) SetFinalized() (types.Transaction, error)

SetFinalized is a paid mutator transaction binding the contract method 0x1de77253.

Solidity: function setFinalized() returns()

func (*KeyperSetSession) SetPublisher 

func (_KeyperSet *KeyperSetSession) SetPublisher(_publisher libcommon.Address) (types.Transaction, error)

SetPublisher is a paid mutator transaction binding the contract method 0xcab63661.

Solidity: function setPublisher(address _publisher) returns()

func (*KeyperSetSession) SetThreshold 

func (_KeyperSet *KeyperSetSession) SetThreshold(_threshold uint64) (types.Transaction, error)

SetThreshold is a paid mutator transaction binding the contract method 0x17c4de35.

Solidity: function setThreshold(uint64 _threshold) returns()

func (*KeyperSetSession) TransferOwnership 

func (_KeyperSet *KeyperSetSession) TransferOwnership(newOwner libcommon.Address) (types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(address newOwner) returns()

type KeyperSetSetPublisherParams 

type KeyperSetSetPublisherParams struct {
	Param__publisher libcommon.Address
}

KeyperSetSetPublisherParams is an auto generated read-only Go binding of transcaction calldata params

func ParseKeyperSetSetPublisherParams 

func ParseKeyperSetSetPublisherParams(calldata []byte) (*KeyperSetSetPublisherParams, error)

Parse SetPublisher method from calldata of a transaction

Solidity: function setPublisher(address _publisher) returns()

type KeyperSetSetThresholdParams 

type KeyperSetSetThresholdParams struct {
	Param__threshold uint64
}

KeyperSetSetThresholdParams is an auto generated read-only Go binding of transcaction calldata params

func ParseKeyperSetSetThresholdParams 

func ParseKeyperSetSetThresholdParams(calldata []byte) (*KeyperSetSetThresholdParams, error)

Parse SetThreshold method from calldata of a transaction

Solidity: function setThreshold(uint64 _threshold) returns()

type KeyperSetTransactor 

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

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

func NewKeyperSetTransactor 

func NewKeyperSetTransactor(address libcommon.Address, transactor bind.ContractTransactor) (*KeyperSetTransactor, error)

NewKeyperSetTransactor creates a new write-only instance of KeyperSet, bound to a specific deployed contract.

func (*KeyperSetTransactor) AddMembers 

func (_KeyperSet *KeyperSetTransactor) AddMembers(opts *bind.TransactOpts, newMembers []libcommon.Address) (types.Transaction, error)

AddMembers is a paid mutator transaction binding the contract method 0x6f4d469b.

Solidity: function addMembers(address[] newMembers) returns()

func (*KeyperSetTransactor) RenounceOwnership 

func (_KeyperSet *KeyperSetTransactor) RenounceOwnership(opts *bind.TransactOpts) (types.Transaction, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*KeyperSetTransactor) SetFinalized 

func (_KeyperSet *KeyperSetTransactor) SetFinalized(opts *bind.TransactOpts) (types.Transaction, error)

SetFinalized is a paid mutator transaction binding the contract method 0x1de77253.

Solidity: function setFinalized() returns()

func (*KeyperSetTransactor) SetPublisher 

func (_KeyperSet *KeyperSetTransactor) SetPublisher(opts *bind.TransactOpts, _publisher libcommon.Address) (types.Transaction, error)

SetPublisher is a paid mutator transaction binding the contract method 0xcab63661.

Solidity: function setPublisher(address _publisher) returns()

func (*KeyperSetTransactor) SetThreshold 

func (_KeyperSet *KeyperSetTransactor) SetThreshold(opts *bind.TransactOpts, _threshold uint64) (types.Transaction, error)

SetThreshold is a paid mutator transaction binding the contract method 0x17c4de35.

Solidity: function setThreshold(uint64 _threshold) returns()

func (*KeyperSetTransactor) TransferOwnership 

func (_KeyperSet *KeyperSetTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner libcommon.Address) (types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(address newOwner) returns()

type KeyperSetTransactorRaw 

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

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

func (*KeyperSetTransactorRaw) Transact 

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

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

func (*KeyperSetTransactorRaw) Transfer 

func (_KeyperSet *KeyperSetTransactorRaw) 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 KeyperSetTransactorSession 

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

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

func (*KeyperSetTransactorSession) AddMembers 

func (_KeyperSet *KeyperSetTransactorSession) AddMembers(newMembers []libcommon.Address) (types.Transaction, error)

AddMembers is a paid mutator transaction binding the contract method 0x6f4d469b.

Solidity: function addMembers(address[] newMembers) returns()

func (*KeyperSetTransactorSession) RenounceOwnership 

func (_KeyperSet *KeyperSetTransactorSession) RenounceOwnership() (types.Transaction, error)

RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.

Solidity: function renounceOwnership() returns()

func (*KeyperSetTransactorSession) SetFinalized 

func (_KeyperSet *KeyperSetTransactorSession) SetFinalized() (types.Transaction, error)

SetFinalized is a paid mutator transaction binding the contract method 0x1de77253.

Solidity: function setFinalized() returns()

func (*KeyperSetTransactorSession) SetPublisher 

func (_KeyperSet *KeyperSetTransactorSession) SetPublisher(_publisher libcommon.Address) (types.Transaction, error)

SetPublisher is a paid mutator transaction binding the contract method 0xcab63661.

Solidity: function setPublisher(address _publisher) returns()

func (*KeyperSetTransactorSession) SetThreshold 

func (_KeyperSet *KeyperSetTransactorSession) SetThreshold(_threshold uint64) (types.Transaction, error)

SetThreshold is a paid mutator transaction binding the contract method 0x17c4de35.

Solidity: function setThreshold(uint64 _threshold) returns()

func (*KeyperSetTransactorSession) TransferOwnership 

func (_KeyperSet *KeyperSetTransactorSession) TransferOwnership(newOwner libcommon.Address) (types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(address newOwner) returns()

type KeyperSetTransferOwnershipParams 

type KeyperSetTransferOwnershipParams struct {
	Param_newOwner libcommon.Address
}

KeyperSetTransferOwnershipParams is an auto generated read-only Go binding of transcaction calldata params

func ParseKeyperSetTransferOwnershipParams 

func ParseKeyperSetTransferOwnershipParams(calldata []byte) (*KeyperSetTransferOwnershipParams, error)

Parse TransferOwnership method from calldata of a transaction

Solidity: function transferOwnership(address newOwner) returns()

type Sequencer 

type Sequencer struct {
	SequencerCaller     // Read-only binding to the contract
	SequencerTransactor // Write-only binding to the contract
	SequencerFilterer   // Log filterer for contract events
}

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

func DeploySequencer 

func DeploySequencer(auth *bind.TransactOpts, backend bind.ContractBackend) (libcommon.Address, types.Transaction, *Sequencer, error)

DeploySequencer deploys a new Ethereum contract, binding an instance of Sequencer to it.

func NewSequencer 

func NewSequencer(address libcommon.Address, backend bind.ContractBackend) (*Sequencer, error)

NewSequencer creates a new instance of Sequencer, bound to a specific deployed contract.

type SequencerCaller 

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

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

func NewSequencerCaller 

func NewSequencerCaller(address libcommon.Address, caller bind.ContractCaller) (*SequencerCaller, error)

NewSequencerCaller creates a new read-only instance of Sequencer, bound to a specific deployed contract.

func (*SequencerCaller) GetTxCountForEon 

func (_Sequencer *SequencerCaller) GetTxCountForEon(opts *bind.CallOpts, eon uint64) (uint64, error)

GetTxCountForEon is a free data retrieval call binding the contract method 0x7bbd164b.

Solidity: function getTxCountForEon(uint64 eon) view returns(uint64)

type SequencerCallerRaw 

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

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

func (*SequencerCallerRaw) Call 

func (_Sequencer *SequencerCallerRaw) 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 SequencerCallerSession 

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

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

func (*SequencerCallerSession) GetTxCountForEon 

func (_Sequencer *SequencerCallerSession) GetTxCountForEon(eon uint64) (uint64, error)

GetTxCountForEon is a free data retrieval call binding the contract method 0x7bbd164b.

Solidity: function getTxCountForEon(uint64 eon) view returns(uint64)

type SequencerDecryptionProgressSubmitted 

type SequencerDecryptionProgressSubmitted struct {
	Message []byte
	Raw     types.Log // Blockchain specific contextual infos
}

SequencerDecryptionProgressSubmitted represents a DecryptionProgressSubmitted event raised by the Sequencer contract.

type SequencerDecryptionProgressSubmittedIterator 

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

SequencerDecryptionProgressSubmittedIterator is returned from FilterDecryptionProgressSubmitted and is used to iterate over the raw logs and unpacked data for DecryptionProgressSubmitted events raised by the Sequencer contract.

func (*SequencerDecryptionProgressSubmittedIterator) Close 

func (it *SequencerDecryptionProgressSubmittedIterator) Close() error

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

func (*SequencerDecryptionProgressSubmittedIterator) Error 

func (it *SequencerDecryptionProgressSubmittedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*SequencerDecryptionProgressSubmittedIterator) Next 

func (it *SequencerDecryptionProgressSubmittedIterator) 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 SequencerFilterer 

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

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

func NewSequencerFilterer 

func NewSequencerFilterer(address libcommon.Address, filterer bind.ContractFilterer) (*SequencerFilterer, error)

NewSequencerFilterer creates a new log filterer instance of Sequencer, bound to a specific deployed contract.

func (*SequencerFilterer) DecryptionProgressSubmittedEventID 

func (_Sequencer *SequencerFilterer) DecryptionProgressSubmittedEventID() libcommon.Hash

func (*SequencerFilterer) FilterDecryptionProgressSubmitted 

func (_Sequencer *SequencerFilterer) FilterDecryptionProgressSubmitted(opts *bind.FilterOpts) (*SequencerDecryptionProgressSubmittedIterator, error)

FilterDecryptionProgressSubmitted is a free log retrieval operation binding the contract event 0xa9a0645b33a70f18b8d490681d637cb46a859ec51707787e6f46b942f90e8f59.

Solidity: event DecryptionProgressSubmitted(bytes message)

func (*SequencerFilterer) FilterTransactionSubmitted 

func (_Sequencer *SequencerFilterer) FilterTransactionSubmitted(opts *bind.FilterOpts) (*SequencerTransactionSubmittedIterator, error)

FilterTransactionSubmitted is a free log retrieval operation binding the contract event 0xa7f1b5467be46c45249fb93063cceef96c63ddad03819246bc7770e32d4f5b7d.

Solidity: event TransactionSubmitted(uint64 eon, uint64 txIndex, bytes32 identityPrefix, address sender, bytes encryptedTransaction, uint256 gasLimit)

func (*SequencerFilterer) ParseDecryptionProgressSubmitted 

func (_Sequencer *SequencerFilterer) ParseDecryptionProgressSubmitted(log types.Log) (*SequencerDecryptionProgressSubmitted, error)

ParseDecryptionProgressSubmitted is a log parse operation binding the contract event 0xa9a0645b33a70f18b8d490681d637cb46a859ec51707787e6f46b942f90e8f59.

Solidity: event DecryptionProgressSubmitted(bytes message)

func (*SequencerFilterer) ParseTransactionSubmitted 

func (_Sequencer *SequencerFilterer) ParseTransactionSubmitted(log types.Log) (*SequencerTransactionSubmitted, error)

ParseTransactionSubmitted is a log parse operation binding the contract event 0xa7f1b5467be46c45249fb93063cceef96c63ddad03819246bc7770e32d4f5b7d.

Solidity: event TransactionSubmitted(uint64 eon, uint64 txIndex, bytes32 identityPrefix, address sender, bytes encryptedTransaction, uint256 gasLimit)

func (*SequencerFilterer) TransactionSubmittedEventID 

func (_Sequencer *SequencerFilterer) TransactionSubmittedEventID() libcommon.Hash

func (*SequencerFilterer) WatchDecryptionProgressSubmitted 

func (_Sequencer *SequencerFilterer) WatchDecryptionProgressSubmitted(opts *bind.WatchOpts, sink chan<- *SequencerDecryptionProgressSubmitted) (event.Subscription, error)

WatchDecryptionProgressSubmitted is a free log subscription operation binding the contract event 0xa9a0645b33a70f18b8d490681d637cb46a859ec51707787e6f46b942f90e8f59.

Solidity: event DecryptionProgressSubmitted(bytes message)

func (*SequencerFilterer) WatchTransactionSubmitted 

func (_Sequencer *SequencerFilterer) WatchTransactionSubmitted(opts *bind.WatchOpts, sink chan<- *SequencerTransactionSubmitted) (event.Subscription, error)

WatchTransactionSubmitted is a free log subscription operation binding the contract event 0xa7f1b5467be46c45249fb93063cceef96c63ddad03819246bc7770e32d4f5b7d.

Solidity: event TransactionSubmitted(uint64 eon, uint64 txIndex, bytes32 identityPrefix, address sender, bytes encryptedTransaction, uint256 gasLimit)

type SequencerRaw 

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

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

func (*SequencerRaw) Call 

func (_Sequencer *SequencerRaw) 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 (*SequencerRaw) Transact 

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

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

func (*SequencerRaw) Transfer 

func (_Sequencer *SequencerRaw) 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 SequencerSession 

type SequencerSession struct {
	Contract     *Sequencer        // 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
}

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

func (*SequencerSession) GetTxCountForEon 

func (_Sequencer *SequencerSession) GetTxCountForEon(eon uint64) (uint64, error)

GetTxCountForEon is a free data retrieval call binding the contract method 0x7bbd164b.

Solidity: function getTxCountForEon(uint64 eon) view returns(uint64)

func (*SequencerSession) SubmitDecryptionProgress 

func (_Sequencer *SequencerSession) SubmitDecryptionProgress(message []byte) (types.Transaction, error)

SubmitDecryptionProgress is a paid mutator transaction binding the contract method 0x2d32522e.

Solidity: function submitDecryptionProgress(bytes message) returns()

func (*SequencerSession) SubmitEncryptedTransaction 

func (_Sequencer *SequencerSession) SubmitEncryptedTransaction(eon uint64, identityPrefix [32]byte, encryptedTransaction []byte, gasLimit *big.Int) (types.Transaction, error)

SubmitEncryptedTransaction is a paid mutator transaction binding the contract method 0x6a69d2e1.

Solidity: function submitEncryptedTransaction(uint64 eon, bytes32 identityPrefix, bytes encryptedTransaction, uint256 gasLimit) payable returns()

type SequencerSubmitDecryptionProgressParams 

type SequencerSubmitDecryptionProgressParams struct {
	Param_message []byte
}

SequencerSubmitDecryptionProgressParams is an auto generated read-only Go binding of transcaction calldata params

func ParseSequencerSubmitDecryptionProgressParams 

func ParseSequencerSubmitDecryptionProgressParams(calldata []byte) (*SequencerSubmitDecryptionProgressParams, error)

Parse SubmitDecryptionProgress method from calldata of a transaction

Solidity: function submitDecryptionProgress(bytes message) returns()

type SequencerSubmitEncryptedTransactionParams 

type SequencerSubmitEncryptedTransactionParams struct {
	Param_eon                  uint64
	Param_identityPrefix       [32]byte
	Param_encryptedTransaction []byte
	Param_gasLimit             *big.Int
}

SequencerSubmitEncryptedTransactionParams is an auto generated read-only Go binding of transcaction calldata params

func ParseSequencerSubmitEncryptedTransactionParams 

func ParseSequencerSubmitEncryptedTransactionParams(calldata []byte) (*SequencerSubmitEncryptedTransactionParams, error)

Parse SubmitEncryptedTransaction method from calldata of a transaction

Solidity: function submitEncryptedTransaction(uint64 eon, bytes32 identityPrefix, bytes encryptedTransaction, uint256 gasLimit) payable returns()

type SequencerTransactionSubmitted 

type SequencerTransactionSubmitted struct {
	Eon                  uint64
	TxIndex              uint64
	IdentityPrefix       [32]byte
	Sender               libcommon.Address
	EncryptedTransaction []byte
	GasLimit             *big.Int
	Raw                  types.Log // Blockchain specific contextual infos
}

SequencerTransactionSubmitted represents a TransactionSubmitted event raised by the Sequencer contract.

type SequencerTransactionSubmittedIterator 

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

SequencerTransactionSubmittedIterator is returned from FilterTransactionSubmitted and is used to iterate over the raw logs and unpacked data for TransactionSubmitted events raised by the Sequencer contract.

func (*SequencerTransactionSubmittedIterator) Close 

func (it *SequencerTransactionSubmittedIterator) Close() error

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

func (*SequencerTransactionSubmittedIterator) Error 

func (it *SequencerTransactionSubmittedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*SequencerTransactionSubmittedIterator) Next 

func (it *SequencerTransactionSubmittedIterator) 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 SequencerTransactor 

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

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

func NewSequencerTransactor 

func NewSequencerTransactor(address libcommon.Address, transactor bind.ContractTransactor) (*SequencerTransactor, error)

NewSequencerTransactor creates a new write-only instance of Sequencer, bound to a specific deployed contract.

func (*SequencerTransactor) SubmitDecryptionProgress 

func (_Sequencer *SequencerTransactor) SubmitDecryptionProgress(opts *bind.TransactOpts, message []byte) (types.Transaction, error)

SubmitDecryptionProgress is a paid mutator transaction binding the contract method 0x2d32522e.

Solidity: function submitDecryptionProgress(bytes message) returns()

func (*SequencerTransactor) SubmitEncryptedTransaction 

func (_Sequencer *SequencerTransactor) SubmitEncryptedTransaction(opts *bind.TransactOpts, eon uint64, identityPrefix [32]byte, encryptedTransaction []byte, gasLimit *big.Int) (types.Transaction, error)

SubmitEncryptedTransaction is a paid mutator transaction binding the contract method 0x6a69d2e1.

Solidity: function submitEncryptedTransaction(uint64 eon, bytes32 identityPrefix, bytes encryptedTransaction, uint256 gasLimit) payable returns()

type SequencerTransactorRaw 

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

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

func (*SequencerTransactorRaw) Transact 

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

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

func (*SequencerTransactorRaw) Transfer 

func (_Sequencer *SequencerTransactorRaw) 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 SequencerTransactorSession 

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

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

func (*SequencerTransactorSession) SubmitDecryptionProgress 

func (_Sequencer *SequencerTransactorSession) SubmitDecryptionProgress(message []byte) (types.Transaction, error)

SubmitDecryptionProgress is a paid mutator transaction binding the contract method 0x2d32522e.

Solidity: function submitDecryptionProgress(bytes message) returns()

func (*SequencerTransactorSession) SubmitEncryptedTransaction 

func (_Sequencer *SequencerTransactorSession) SubmitEncryptedTransaction(eon uint64, identityPrefix [32]byte, encryptedTransaction []byte, gasLimit *big.Int) (types.Transaction, error)

SubmitEncryptedTransaction is a paid mutator transaction binding the contract method 0x6a69d2e1.

Solidity: function submitEncryptedTransaction(uint64 eon, bytes32 identityPrefix, bytes encryptedTransaction, uint256 gasLimit) payable returns()

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.