librariesgen

package
v0.0.0-...-5793453 Latest Latest
Warning

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

 Go to latest Published: Apr 16, 2024 License: MIT Imports: 9 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var AddressAliasHelperABI = AddressAliasHelperMetaData.ABI

AddressAliasHelperABI is the input ABI used to generate the binding from. Deprecated: Use AddressAliasHelperMetaData.ABI instead.

View Source 
var AddressAliasHelperBin = AddressAliasHelperMetaData.Bin

AddressAliasHelperBin is the compiled bytecode used for deploying new contracts. Deprecated: Use AddressAliasHelperMetaData.Bin instead.

View Source 
var AddressAliasHelperMetaData = &bind.MetaData{
	ABI: "[]",
	Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212205dd9b78bd73a6499ec72a1c251c929b59ce114d5f4e42fb039f5b2aad3f3768f64736f6c63430008090033",
}

AddressAliasHelperMetaData contains all meta data concerning the AddressAliasHelper contract.

View Source 
var AdminFallbackProxyABI = AdminFallbackProxyMetaData.ABI

AdminFallbackProxyABI is the input ABI used to generate the binding from. Deprecated: Use AdminFallbackProxyMetaData.ABI instead.

View Source 
var AdminFallbackProxyBin = AdminFallbackProxyMetaData.Bin

AdminFallbackProxyBin is the compiled bytecode used for deploying new contracts. Deprecated: Use AdminFallbackProxyMetaData.Bin instead.

View Source 
var AdminFallbackProxyMetaData = &bind.MetaData{
	ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"UpgradedSecondary\",\"type\":\"event\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}]",
	Bin: "0x608060405234801561001057600080fd5b506101cf806100206000396000f3fe60806040523661001357610011610017565b005b6100115b610027610022610029565b6100f2565b565b6000600436101561006f5760405162461bcd60e51b815260206004820152600b60248201526a4e4f5f46554e435f53494760a81b60448201526064015b60405180910390fd5b60003361007a610116565b6001600160a01b0316141561009657610091610149565b61009e565b61009e610171565b90506001600160a01b0381163b6100ed5760405162461bcd60e51b815260206004820152601360248201527215105491d15517d393d517d0d3d395149050d5606a1b6044820152606401610066565b919050565b3660008037600080366000845af43d6000803e808015610111573d6000f35b3d6000fd5b60007fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d61035b546001600160a01b0316919050565b60007f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc61013a565b60007f2b1dbce74324248c222f0ec2d5ed7bd323cfc425b336f0253c5ccfda7265546d61013a56fea26469706673582212201903f8011eaea0afb60eecdae460623dc2140618a9a31302eb25eaa6bc8db0f964736f6c63430008090033",
}

AdminFallbackProxyMetaData contains all meta data concerning the AdminFallbackProxy contract.

View Source 
var ArbitrumCheckerABI = ArbitrumCheckerMetaData.ABI

ArbitrumCheckerABI is the input ABI used to generate the binding from. Deprecated: Use ArbitrumCheckerMetaData.ABI instead.

View Source 
var ArbitrumCheckerBin = ArbitrumCheckerMetaData.Bin

ArbitrumCheckerBin is the compiled bytecode used for deploying new contracts. Deprecated: Use ArbitrumCheckerMetaData.Bin instead.

View Source 
var ArbitrumCheckerMetaData = &bind.MetaData{
	ABI: "[]",
	Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220e2f9ae213929c71868c8d8acb2b0432518ce1bf530d750ba4e068b0475e3acab64736f6c63430008090033",
}

ArbitrumCheckerMetaData contains all meta data concerning the ArbitrumChecker contract.

View Source 
var CryptographyPrimitivesABI = CryptographyPrimitivesMetaData.ABI

CryptographyPrimitivesABI is the input ABI used to generate the binding from. Deprecated: Use CryptographyPrimitivesMetaData.ABI instead.

View Source 
var CryptographyPrimitivesBin = CryptographyPrimitivesMetaData.Bin

CryptographyPrimitivesBin is the compiled bytecode used for deploying new contracts. Deprecated: Use CryptographyPrimitivesMetaData.Bin instead.

View Source 
var CryptographyPrimitivesMetaData = &bind.MetaData{
	ABI: "[]",
	Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220aa9d4b9334e46a0fa7a53ec158ee0d45f55ca1c4ef60365dea5f942b83c999cd64736f6c63430008090033",
}

CryptographyPrimitivesMetaData contains all meta data concerning the CryptographyPrimitives contract.

View Source 
var DelegateCallAwareABI = DelegateCallAwareMetaData.ABI

DelegateCallAwareABI is the input ABI used to generate the binding from. Deprecated: Use DelegateCallAwareMetaData.ABI instead.

View Source 
var DelegateCallAwareMetaData = &bind.MetaData{
	ABI: "[]",
}

DelegateCallAwareMetaData contains all meta data concerning the DelegateCallAware contract.

View Source 
var DoubleLogicERC1967UpgradeABI = DoubleLogicERC1967UpgradeMetaData.ABI

DoubleLogicERC1967UpgradeABI is the input ABI used to generate the binding from. Deprecated: Use DoubleLogicERC1967UpgradeMetaData.ABI instead.

View Source 
var DoubleLogicERC1967UpgradeMetaData = &bind.MetaData{
	ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"UpgradedSecondary\",\"type\":\"event\"}]",
}

DoubleLogicERC1967UpgradeMetaData contains all meta data concerning the DoubleLogicERC1967Upgrade contract.

View Source 
var DoubleLogicUUPSUpgradeableABI = DoubleLogicUUPSUpgradeableMetaData.ABI

DoubleLogicUUPSUpgradeableABI is the input ABI used to generate the binding from. Deprecated: Use DoubleLogicUUPSUpgradeableMetaData.ABI instead.

View Source 
var DoubleLogicUUPSUpgradeableMetaData = &bind.MetaData{
	ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"UpgradedSecondary\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeSecondaryTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeSecondaryToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]",
}

DoubleLogicUUPSUpgradeableMetaData contains all meta data concerning the DoubleLogicUUPSUpgradeable contract.

View Source 
var GasRefundEnabledABI = GasRefundEnabledMetaData.ABI

GasRefundEnabledABI is the input ABI used to generate the binding from. Deprecated: Use GasRefundEnabledMetaData.ABI instead.

View Source 
var GasRefundEnabledMetaData = &bind.MetaData{
	ABI: "[]",
}

GasRefundEnabledMetaData contains all meta data concerning the GasRefundEnabled contract.

View Source 
var IGasRefunderABI = IGasRefunderMetaData.ABI

IGasRefunderABI is the input ABI used to generate the binding from. Deprecated: Use IGasRefunderMetaData.ABI instead.

View Source 
var IGasRefunderMetaData = &bind.MetaData{
	ABI: "[{\"inputs\":[{\"internalType\":\"addresspayable\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"gasUsed\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"calldataSize\",\"type\":\"uint256\"}],\"name\":\"onGasSpent\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
}

IGasRefunderMetaData contains all meta data concerning the IGasRefunder contract.

View Source 
var IReader4844ABI = IReader4844MetaData.ABI

IReader4844ABI is the input ABI used to generate the binding from. Deprecated: Use IReader4844MetaData.ABI instead.

View Source 
var IReader4844MetaData = &bind.MetaData{
	ABI: "[{\"inputs\":[],\"name\":\"getBlobBaseFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getDataHashes\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
}

IReader4844MetaData contains all meta data concerning the IReader4844 contract.

View Source 
var MerkleLibABI = MerkleLibMetaData.ABI

MerkleLibABI is the input ABI used to generate the binding from. Deprecated: Use MerkleLibMetaData.ABI instead.

View Source 
var MerkleLibBin = MerkleLibMetaData.Bin

MerkleLibBin is the compiled bytecode used for deploying new contracts. Deprecated: Use MerkleLibMetaData.Bin instead.

View Source 
var MerkleLibMetaData = &bind.MetaData{
	ABI: "[]",
	Bin: "0x60566037600b82828239805160001a607314602a57634e487b7160e01b600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212209b5ab4b1b7eef937df1fd847f2beb0ecc8f14e4e42091d3f8da15d04e327cd9364736f6c63430008090033",
}

MerkleLibMetaData contains all meta data concerning the MerkleLib contract.

View Source 
var UUPSNotUpgradeableABI = UUPSNotUpgradeableMetaData.ABI

UUPSNotUpgradeableABI is the input ABI used to generate the binding from. Deprecated: Use UUPSNotUpgradeableMetaData.ABI instead.

View Source 
var UUPSNotUpgradeableMetaData = &bind.MetaData{
	ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"UpgradedSecondary\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
}

UUPSNotUpgradeableMetaData contains all meta data concerning the UUPSNotUpgradeable contract.

Functions

This section is empty.

Types

type AddressAliasHelper 

type AddressAliasHelper struct {
	AddressAliasHelperCaller     // Read-only binding to the contract
	AddressAliasHelperTransactor // Write-only binding to the contract
	AddressAliasHelperFilterer   // Log filterer for contract events
}

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

func DeployAddressAliasHelper 

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

DeployAddressAliasHelper deploys a new Ethereum contract, binding an instance of AddressAliasHelper to it.

func NewAddressAliasHelper 

func NewAddressAliasHelper(address common.Address, backend bind.ContractBackend) (*AddressAliasHelper, error)

NewAddressAliasHelper creates a new instance of AddressAliasHelper, bound to a specific deployed contract.

type AddressAliasHelperCaller 

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

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

func NewAddressAliasHelperCaller 

func NewAddressAliasHelperCaller(address common.Address, caller bind.ContractCaller) (*AddressAliasHelperCaller, error)

NewAddressAliasHelperCaller creates a new read-only instance of AddressAliasHelper, bound to a specific deployed contract.

type AddressAliasHelperCallerRaw 

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

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

func (*AddressAliasHelperCallerRaw) Call 

func (_AddressAliasHelper *AddressAliasHelperCallerRaw) 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 AddressAliasHelperCallerSession 

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

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

type AddressAliasHelperFilterer 

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

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

func NewAddressAliasHelperFilterer 

func NewAddressAliasHelperFilterer(address common.Address, filterer bind.ContractFilterer) (*AddressAliasHelperFilterer, error)

NewAddressAliasHelperFilterer creates a new log filterer instance of AddressAliasHelper, bound to a specific deployed contract.

type AddressAliasHelperRaw 

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

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

func (*AddressAliasHelperRaw) Call 

func (_AddressAliasHelper *AddressAliasHelperRaw) 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 (*AddressAliasHelperRaw) Transact 

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

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

func (*AddressAliasHelperRaw) Transfer 

func (_AddressAliasHelper *AddressAliasHelperRaw) 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 AddressAliasHelperSession 

type AddressAliasHelperSession struct {
	Contract     *AddressAliasHelper // 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
}

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

type AddressAliasHelperTransactor 

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

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

func NewAddressAliasHelperTransactor 

func NewAddressAliasHelperTransactor(address common.Address, transactor bind.ContractTransactor) (*AddressAliasHelperTransactor, error)

NewAddressAliasHelperTransactor creates a new write-only instance of AddressAliasHelper, bound to a specific deployed contract.

type AddressAliasHelperTransactorRaw 

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

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

func (*AddressAliasHelperTransactorRaw) Transact 

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

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

func (*AddressAliasHelperTransactorRaw) Transfer 

func (_AddressAliasHelper *AddressAliasHelperTransactorRaw) 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 AddressAliasHelperTransactorSession 

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

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

type AdminFallbackProxy 

type AdminFallbackProxy struct {
	AdminFallbackProxyCaller     // Read-only binding to the contract
	AdminFallbackProxyTransactor // Write-only binding to the contract
	AdminFallbackProxyFilterer   // Log filterer for contract events
}

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

func DeployAdminFallbackProxy 

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

DeployAdminFallbackProxy deploys a new Ethereum contract, binding an instance of AdminFallbackProxy to it.

func NewAdminFallbackProxy 

func NewAdminFallbackProxy(address common.Address, backend bind.ContractBackend) (*AdminFallbackProxy, error)

NewAdminFallbackProxy creates a new instance of AdminFallbackProxy, bound to a specific deployed contract.

type AdminFallbackProxyAdminChanged 

type AdminFallbackProxyAdminChanged struct {
	PreviousAdmin common.Address
	NewAdmin      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

AdminFallbackProxyAdminChanged represents a AdminChanged event raised by the AdminFallbackProxy contract.

type AdminFallbackProxyAdminChangedIterator 

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

AdminFallbackProxyAdminChangedIterator is returned from FilterAdminChanged and is used to iterate over the raw logs and unpacked data for AdminChanged events raised by the AdminFallbackProxy contract.

func (*AdminFallbackProxyAdminChangedIterator) Close 

func (it *AdminFallbackProxyAdminChangedIterator) Close() error

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

func (*AdminFallbackProxyAdminChangedIterator) Error 

func (it *AdminFallbackProxyAdminChangedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*AdminFallbackProxyAdminChangedIterator) Next 

func (it *AdminFallbackProxyAdminChangedIterator) 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 AdminFallbackProxyBeaconUpgraded 

type AdminFallbackProxyBeaconUpgraded struct {
	Beacon common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

AdminFallbackProxyBeaconUpgraded represents a BeaconUpgraded event raised by the AdminFallbackProxy contract.

type AdminFallbackProxyBeaconUpgradedIterator 

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

AdminFallbackProxyBeaconUpgradedIterator is returned from FilterBeaconUpgraded and is used to iterate over the raw logs and unpacked data for BeaconUpgraded events raised by the AdminFallbackProxy contract.

func (*AdminFallbackProxyBeaconUpgradedIterator) Close 

func (it *AdminFallbackProxyBeaconUpgradedIterator) Close() error

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

func (*AdminFallbackProxyBeaconUpgradedIterator) Error 

func (it *AdminFallbackProxyBeaconUpgradedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*AdminFallbackProxyBeaconUpgradedIterator) Next 

func (it *AdminFallbackProxyBeaconUpgradedIterator) 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 AdminFallbackProxyCaller 

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

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

func NewAdminFallbackProxyCaller 

func NewAdminFallbackProxyCaller(address common.Address, caller bind.ContractCaller) (*AdminFallbackProxyCaller, error)

NewAdminFallbackProxyCaller creates a new read-only instance of AdminFallbackProxy, bound to a specific deployed contract.

type AdminFallbackProxyCallerRaw 

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

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

func (*AdminFallbackProxyCallerRaw) Call 

func (_AdminFallbackProxy *AdminFallbackProxyCallerRaw) 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 AdminFallbackProxyCallerSession 

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

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

type AdminFallbackProxyFilterer 

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

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

func NewAdminFallbackProxyFilterer 

func NewAdminFallbackProxyFilterer(address common.Address, filterer bind.ContractFilterer) (*AdminFallbackProxyFilterer, error)

NewAdminFallbackProxyFilterer creates a new log filterer instance of AdminFallbackProxy, bound to a specific deployed contract.

func (*AdminFallbackProxyFilterer) FilterAdminChanged 

func (_AdminFallbackProxy *AdminFallbackProxyFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*AdminFallbackProxyAdminChangedIterator, error)

FilterAdminChanged is a free log retrieval operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f.

Solidity: event AdminChanged(address previousAdmin, address newAdmin)

func (*AdminFallbackProxyFilterer) FilterBeaconUpgraded 

func (_AdminFallbackProxy *AdminFallbackProxyFilterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*AdminFallbackProxyBeaconUpgradedIterator, error)

FilterBeaconUpgraded is a free log retrieval operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e.

Solidity: event BeaconUpgraded(address indexed beacon)

func (*AdminFallbackProxyFilterer) FilterUpgraded 

func (_AdminFallbackProxy *AdminFallbackProxyFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*AdminFallbackProxyUpgradedIterator, error)

FilterUpgraded is a free log retrieval operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b.

Solidity: event Upgraded(address indexed implementation)

func (*AdminFallbackProxyFilterer) FilterUpgradedSecondary 

func (_AdminFallbackProxy *AdminFallbackProxyFilterer) FilterUpgradedSecondary(opts *bind.FilterOpts, implementation []common.Address) (*AdminFallbackProxyUpgradedSecondaryIterator, error)

FilterUpgradedSecondary is a free log retrieval operation binding the contract event 0xf7eed2a7fabbf1bec8d55ed5e785cc76622376dde5df4ff15470551e030b8134.

Solidity: event UpgradedSecondary(address indexed implementation)

func (*AdminFallbackProxyFilterer) ParseAdminChanged 

func (_AdminFallbackProxy *AdminFallbackProxyFilterer) ParseAdminChanged(log types.Log) (*AdminFallbackProxyAdminChanged, error)

ParseAdminChanged is a log parse operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f.

Solidity: event AdminChanged(address previousAdmin, address newAdmin)

func (*AdminFallbackProxyFilterer) ParseBeaconUpgraded 

func (_AdminFallbackProxy *AdminFallbackProxyFilterer) ParseBeaconUpgraded(log types.Log) (*AdminFallbackProxyBeaconUpgraded, error)

ParseBeaconUpgraded is a log parse operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e.

Solidity: event BeaconUpgraded(address indexed beacon)

func (*AdminFallbackProxyFilterer) ParseUpgraded 

func (_AdminFallbackProxy *AdminFallbackProxyFilterer) ParseUpgraded(log types.Log) (*AdminFallbackProxyUpgraded, error)

ParseUpgraded is a log parse operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b.

Solidity: event Upgraded(address indexed implementation)

func (*AdminFallbackProxyFilterer) ParseUpgradedSecondary 

func (_AdminFallbackProxy *AdminFallbackProxyFilterer) ParseUpgradedSecondary(log types.Log) (*AdminFallbackProxyUpgradedSecondary, error)

ParseUpgradedSecondary is a log parse operation binding the contract event 0xf7eed2a7fabbf1bec8d55ed5e785cc76622376dde5df4ff15470551e030b8134.

Solidity: event UpgradedSecondary(address indexed implementation)

func (*AdminFallbackProxyFilterer) WatchAdminChanged 

func (_AdminFallbackProxy *AdminFallbackProxyFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *AdminFallbackProxyAdminChanged) (event.Subscription, error)

WatchAdminChanged is a free log subscription operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f.

Solidity: event AdminChanged(address previousAdmin, address newAdmin)

func (*AdminFallbackProxyFilterer) WatchBeaconUpgraded 

func (_AdminFallbackProxy *AdminFallbackProxyFilterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *AdminFallbackProxyBeaconUpgraded, beacon []common.Address) (event.Subscription, error)

WatchBeaconUpgraded is a free log subscription operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e.

Solidity: event BeaconUpgraded(address indexed beacon)

func (*AdminFallbackProxyFilterer) WatchUpgraded 

func (_AdminFallbackProxy *AdminFallbackProxyFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *AdminFallbackProxyUpgraded, implementation []common.Address) (event.Subscription, error)

WatchUpgraded is a free log subscription operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b.

Solidity: event Upgraded(address indexed implementation)

func (*AdminFallbackProxyFilterer) WatchUpgradedSecondary 

func (_AdminFallbackProxy *AdminFallbackProxyFilterer) WatchUpgradedSecondary(opts *bind.WatchOpts, sink chan<- *AdminFallbackProxyUpgradedSecondary, implementation []common.Address) (event.Subscription, error)

WatchUpgradedSecondary is a free log subscription operation binding the contract event 0xf7eed2a7fabbf1bec8d55ed5e785cc76622376dde5df4ff15470551e030b8134.

Solidity: event UpgradedSecondary(address indexed implementation)

type AdminFallbackProxyRaw 

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

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

func (*AdminFallbackProxyRaw) Call 

func (_AdminFallbackProxy *AdminFallbackProxyRaw) 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 (*AdminFallbackProxyRaw) Transact 

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

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

func (*AdminFallbackProxyRaw) Transfer 

func (_AdminFallbackProxy *AdminFallbackProxyRaw) 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 AdminFallbackProxySession 

type AdminFallbackProxySession struct {
	Contract     *AdminFallbackProxy // 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
}

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

func (*AdminFallbackProxySession) Fallback 

func (_AdminFallbackProxy *AdminFallbackProxySession) Fallback(calldata []byte) (*types.Transaction, error)

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

Solidity: fallback() payable returns()

func (*AdminFallbackProxySession) Receive 

func (_AdminFallbackProxy *AdminFallbackProxySession) Receive() (*types.Transaction, error)

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

Solidity: receive() payable returns()

type AdminFallbackProxyTransactor 

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

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

func NewAdminFallbackProxyTransactor 

func NewAdminFallbackProxyTransactor(address common.Address, transactor bind.ContractTransactor) (*AdminFallbackProxyTransactor, error)

NewAdminFallbackProxyTransactor creates a new write-only instance of AdminFallbackProxy, bound to a specific deployed contract.

func (*AdminFallbackProxyTransactor) Fallback 

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

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

Solidity: fallback() payable returns()

func (*AdminFallbackProxyTransactor) Receive 

func (_AdminFallbackProxy *AdminFallbackProxyTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

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

Solidity: receive() payable returns()

type AdminFallbackProxyTransactorRaw 

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

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

func (*AdminFallbackProxyTransactorRaw) Transact 

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

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

func (*AdminFallbackProxyTransactorRaw) Transfer 

func (_AdminFallbackProxy *AdminFallbackProxyTransactorRaw) 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 AdminFallbackProxyTransactorSession 

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

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

func (*AdminFallbackProxyTransactorSession) Fallback 

func (_AdminFallbackProxy *AdminFallbackProxyTransactorSession) Fallback(calldata []byte) (*types.Transaction, error)

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

Solidity: fallback() payable returns()

func (*AdminFallbackProxyTransactorSession) Receive 

func (_AdminFallbackProxy *AdminFallbackProxyTransactorSession) Receive() (*types.Transaction, error)

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

Solidity: receive() payable returns()

type AdminFallbackProxyUpgraded 

type AdminFallbackProxyUpgraded struct {
	Implementation common.Address
	Raw            types.Log // Blockchain specific contextual infos
}

AdminFallbackProxyUpgraded represents a Upgraded event raised by the AdminFallbackProxy contract.

type AdminFallbackProxyUpgradedIterator 

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

AdminFallbackProxyUpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the AdminFallbackProxy contract.

func (*AdminFallbackProxyUpgradedIterator) Close 

func (it *AdminFallbackProxyUpgradedIterator) Close() error

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

func (*AdminFallbackProxyUpgradedIterator) Error 

func (it *AdminFallbackProxyUpgradedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*AdminFallbackProxyUpgradedIterator) Next 

func (it *AdminFallbackProxyUpgradedIterator) 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 AdminFallbackProxyUpgradedSecondary 

type AdminFallbackProxyUpgradedSecondary struct {
	Implementation common.Address
	Raw            types.Log // Blockchain specific contextual infos
}

AdminFallbackProxyUpgradedSecondary represents a UpgradedSecondary event raised by the AdminFallbackProxy contract.

type AdminFallbackProxyUpgradedSecondaryIterator 

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

AdminFallbackProxyUpgradedSecondaryIterator is returned from FilterUpgradedSecondary and is used to iterate over the raw logs and unpacked data for UpgradedSecondary events raised by the AdminFallbackProxy contract.

func (*AdminFallbackProxyUpgradedSecondaryIterator) Close 

func (it *AdminFallbackProxyUpgradedSecondaryIterator) Close() error

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

func (*AdminFallbackProxyUpgradedSecondaryIterator) Error 

func (it *AdminFallbackProxyUpgradedSecondaryIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*AdminFallbackProxyUpgradedSecondaryIterator) Next 

func (it *AdminFallbackProxyUpgradedSecondaryIterator) 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 ArbitrumChecker 

type ArbitrumChecker struct {
	ArbitrumCheckerCaller     // Read-only binding to the contract
	ArbitrumCheckerTransactor // Write-only binding to the contract
	ArbitrumCheckerFilterer   // Log filterer for contract events
}

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

func DeployArbitrumChecker 

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

DeployArbitrumChecker deploys a new Ethereum contract, binding an instance of ArbitrumChecker to it.

func NewArbitrumChecker 

func NewArbitrumChecker(address common.Address, backend bind.ContractBackend) (*ArbitrumChecker, error)

NewArbitrumChecker creates a new instance of ArbitrumChecker, bound to a specific deployed contract.

type ArbitrumCheckerCaller 

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

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

func NewArbitrumCheckerCaller 

func NewArbitrumCheckerCaller(address common.Address, caller bind.ContractCaller) (*ArbitrumCheckerCaller, error)

NewArbitrumCheckerCaller creates a new read-only instance of ArbitrumChecker, bound to a specific deployed contract.

type ArbitrumCheckerCallerRaw 

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

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

func (*ArbitrumCheckerCallerRaw) Call 

func (_ArbitrumChecker *ArbitrumCheckerCallerRaw) 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 ArbitrumCheckerCallerSession 

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

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

type ArbitrumCheckerFilterer 

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

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

func NewArbitrumCheckerFilterer 

func NewArbitrumCheckerFilterer(address common.Address, filterer bind.ContractFilterer) (*ArbitrumCheckerFilterer, error)

NewArbitrumCheckerFilterer creates a new log filterer instance of ArbitrumChecker, bound to a specific deployed contract.

type ArbitrumCheckerRaw 

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

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

func (*ArbitrumCheckerRaw) Call 

func (_ArbitrumChecker *ArbitrumCheckerRaw) 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 (*ArbitrumCheckerRaw) Transact 

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

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

func (*ArbitrumCheckerRaw) Transfer 

func (_ArbitrumChecker *ArbitrumCheckerRaw) 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 ArbitrumCheckerSession 

type ArbitrumCheckerSession struct {
	Contract     *ArbitrumChecker  // 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
}

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

type ArbitrumCheckerTransactor 

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

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

func NewArbitrumCheckerTransactor 

func NewArbitrumCheckerTransactor(address common.Address, transactor bind.ContractTransactor) (*ArbitrumCheckerTransactor, error)

NewArbitrumCheckerTransactor creates a new write-only instance of ArbitrumChecker, bound to a specific deployed contract.

type ArbitrumCheckerTransactorRaw 

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

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

func (*ArbitrumCheckerTransactorRaw) Transact 

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

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

func (*ArbitrumCheckerTransactorRaw) Transfer 

func (_ArbitrumChecker *ArbitrumCheckerTransactorRaw) 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 ArbitrumCheckerTransactorSession 

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

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

type CryptographyPrimitives 

type CryptographyPrimitives struct {
	CryptographyPrimitivesCaller     // Read-only binding to the contract
	CryptographyPrimitivesTransactor // Write-only binding to the contract
	CryptographyPrimitivesFilterer   // Log filterer for contract events
}

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

func DeployCryptographyPrimitives 

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

DeployCryptographyPrimitives deploys a new Ethereum contract, binding an instance of CryptographyPrimitives to it.

func NewCryptographyPrimitives 

func NewCryptographyPrimitives(address common.Address, backend bind.ContractBackend) (*CryptographyPrimitives, error)

NewCryptographyPrimitives creates a new instance of CryptographyPrimitives, bound to a specific deployed contract.

type CryptographyPrimitivesCaller 

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

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

func NewCryptographyPrimitivesCaller 

func NewCryptographyPrimitivesCaller(address common.Address, caller bind.ContractCaller) (*CryptographyPrimitivesCaller, error)

NewCryptographyPrimitivesCaller creates a new read-only instance of CryptographyPrimitives, bound to a specific deployed contract.

type CryptographyPrimitivesCallerRaw 

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

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

func (*CryptographyPrimitivesCallerRaw) Call 

func (_CryptographyPrimitives *CryptographyPrimitivesCallerRaw) 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 CryptographyPrimitivesCallerSession 

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

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

type CryptographyPrimitivesFilterer 

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

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

func NewCryptographyPrimitivesFilterer 

func NewCryptographyPrimitivesFilterer(address common.Address, filterer bind.ContractFilterer) (*CryptographyPrimitivesFilterer, error)

NewCryptographyPrimitivesFilterer creates a new log filterer instance of CryptographyPrimitives, bound to a specific deployed contract.

type CryptographyPrimitivesRaw 

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

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

func (*CryptographyPrimitivesRaw) Call 

func (_CryptographyPrimitives *CryptographyPrimitivesRaw) 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 (*CryptographyPrimitivesRaw) Transact 

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

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

func (*CryptographyPrimitivesRaw) Transfer 

func (_CryptographyPrimitives *CryptographyPrimitivesRaw) 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 CryptographyPrimitivesSession 

type CryptographyPrimitivesSession struct {
	Contract     *CryptographyPrimitives // 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
}

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

type CryptographyPrimitivesTransactor 

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

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

func NewCryptographyPrimitivesTransactor 

func NewCryptographyPrimitivesTransactor(address common.Address, transactor bind.ContractTransactor) (*CryptographyPrimitivesTransactor, error)

NewCryptographyPrimitivesTransactor creates a new write-only instance of CryptographyPrimitives, bound to a specific deployed contract.

type CryptographyPrimitivesTransactorRaw 

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

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

func (*CryptographyPrimitivesTransactorRaw) Transact 

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

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

func (*CryptographyPrimitivesTransactorRaw) Transfer 

func (_CryptographyPrimitives *CryptographyPrimitivesTransactorRaw) 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 CryptographyPrimitivesTransactorSession 

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

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

type DelegateCallAware 

type DelegateCallAware struct {
	DelegateCallAwareCaller     // Read-only binding to the contract
	DelegateCallAwareTransactor // Write-only binding to the contract
	DelegateCallAwareFilterer   // Log filterer for contract events
}

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

func NewDelegateCallAware 

func NewDelegateCallAware(address common.Address, backend bind.ContractBackend) (*DelegateCallAware, error)

NewDelegateCallAware creates a new instance of DelegateCallAware, bound to a specific deployed contract.

type DelegateCallAwareCaller 

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

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

func NewDelegateCallAwareCaller 

func NewDelegateCallAwareCaller(address common.Address, caller bind.ContractCaller) (*DelegateCallAwareCaller, error)

NewDelegateCallAwareCaller creates a new read-only instance of DelegateCallAware, bound to a specific deployed contract.

type DelegateCallAwareCallerRaw 

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

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

func (*DelegateCallAwareCallerRaw) Call 

func (_DelegateCallAware *DelegateCallAwareCallerRaw) 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 DelegateCallAwareCallerSession 

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

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

type DelegateCallAwareFilterer 

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

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

func NewDelegateCallAwareFilterer 

func NewDelegateCallAwareFilterer(address common.Address, filterer bind.ContractFilterer) (*DelegateCallAwareFilterer, error)

NewDelegateCallAwareFilterer creates a new log filterer instance of DelegateCallAware, bound to a specific deployed contract.

type DelegateCallAwareRaw 

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

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

func (*DelegateCallAwareRaw) Call 

func (_DelegateCallAware *DelegateCallAwareRaw) 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 (*DelegateCallAwareRaw) Transact 

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

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

func (*DelegateCallAwareRaw) Transfer 

func (_DelegateCallAware *DelegateCallAwareRaw) 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 DelegateCallAwareSession 

type DelegateCallAwareSession struct {
	Contract     *DelegateCallAware // 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
}

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

type DelegateCallAwareTransactor 

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

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

func NewDelegateCallAwareTransactor 

func NewDelegateCallAwareTransactor(address common.Address, transactor bind.ContractTransactor) (*DelegateCallAwareTransactor, error)

NewDelegateCallAwareTransactor creates a new write-only instance of DelegateCallAware, bound to a specific deployed contract.

type DelegateCallAwareTransactorRaw 

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

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

func (*DelegateCallAwareTransactorRaw) Transact 

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

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

func (*DelegateCallAwareTransactorRaw) Transfer 

func (_DelegateCallAware *DelegateCallAwareTransactorRaw) 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 DelegateCallAwareTransactorSession 

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

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

type DoubleLogicERC1967Upgrade 

type DoubleLogicERC1967Upgrade struct {
	DoubleLogicERC1967UpgradeCaller     // Read-only binding to the contract
	DoubleLogicERC1967UpgradeTransactor // Write-only binding to the contract
	DoubleLogicERC1967UpgradeFilterer   // Log filterer for contract events
}

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

func NewDoubleLogicERC1967Upgrade 

func NewDoubleLogicERC1967Upgrade(address common.Address, backend bind.ContractBackend) (*DoubleLogicERC1967Upgrade, error)

NewDoubleLogicERC1967Upgrade creates a new instance of DoubleLogicERC1967Upgrade, bound to a specific deployed contract.

type DoubleLogicERC1967UpgradeAdminChanged 

type DoubleLogicERC1967UpgradeAdminChanged struct {
	PreviousAdmin common.Address
	NewAdmin      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

DoubleLogicERC1967UpgradeAdminChanged represents a AdminChanged event raised by the DoubleLogicERC1967Upgrade contract.

type DoubleLogicERC1967UpgradeAdminChangedIterator 

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

DoubleLogicERC1967UpgradeAdminChangedIterator is returned from FilterAdminChanged and is used to iterate over the raw logs and unpacked data for AdminChanged events raised by the DoubleLogicERC1967Upgrade contract.

func (*DoubleLogicERC1967UpgradeAdminChangedIterator) Close 

func (it *DoubleLogicERC1967UpgradeAdminChangedIterator) Close() error

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

func (*DoubleLogicERC1967UpgradeAdminChangedIterator) Error 

func (it *DoubleLogicERC1967UpgradeAdminChangedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DoubleLogicERC1967UpgradeAdminChangedIterator) Next 

func (it *DoubleLogicERC1967UpgradeAdminChangedIterator) 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 DoubleLogicERC1967UpgradeBeaconUpgraded 

type DoubleLogicERC1967UpgradeBeaconUpgraded struct {
	Beacon common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

DoubleLogicERC1967UpgradeBeaconUpgraded represents a BeaconUpgraded event raised by the DoubleLogicERC1967Upgrade contract.

type DoubleLogicERC1967UpgradeBeaconUpgradedIterator 

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

DoubleLogicERC1967UpgradeBeaconUpgradedIterator is returned from FilterBeaconUpgraded and is used to iterate over the raw logs and unpacked data for BeaconUpgraded events raised by the DoubleLogicERC1967Upgrade contract.

func (*DoubleLogicERC1967UpgradeBeaconUpgradedIterator) Close 

func (it *DoubleLogicERC1967UpgradeBeaconUpgradedIterator) Close() error

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

func (*DoubleLogicERC1967UpgradeBeaconUpgradedIterator) Error 

func (it *DoubleLogicERC1967UpgradeBeaconUpgradedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DoubleLogicERC1967UpgradeBeaconUpgradedIterator) Next 

func (it *DoubleLogicERC1967UpgradeBeaconUpgradedIterator) 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 DoubleLogicERC1967UpgradeCaller 

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

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

func NewDoubleLogicERC1967UpgradeCaller 

func NewDoubleLogicERC1967UpgradeCaller(address common.Address, caller bind.ContractCaller) (*DoubleLogicERC1967UpgradeCaller, error)

NewDoubleLogicERC1967UpgradeCaller creates a new read-only instance of DoubleLogicERC1967Upgrade, bound to a specific deployed contract.

type DoubleLogicERC1967UpgradeCallerRaw 

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

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

func (*DoubleLogicERC1967UpgradeCallerRaw) Call 

func (_DoubleLogicERC1967Upgrade *DoubleLogicERC1967UpgradeCallerRaw) 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 DoubleLogicERC1967UpgradeCallerSession 

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

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

type DoubleLogicERC1967UpgradeFilterer 

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

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

func NewDoubleLogicERC1967UpgradeFilterer 

func NewDoubleLogicERC1967UpgradeFilterer(address common.Address, filterer bind.ContractFilterer) (*DoubleLogicERC1967UpgradeFilterer, error)

NewDoubleLogicERC1967UpgradeFilterer creates a new log filterer instance of DoubleLogicERC1967Upgrade, bound to a specific deployed contract.

func (*DoubleLogicERC1967UpgradeFilterer) FilterAdminChanged 

func (_DoubleLogicERC1967Upgrade *DoubleLogicERC1967UpgradeFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*DoubleLogicERC1967UpgradeAdminChangedIterator, error)

FilterAdminChanged is a free log retrieval operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f.

Solidity: event AdminChanged(address previousAdmin, address newAdmin)

func (*DoubleLogicERC1967UpgradeFilterer) FilterBeaconUpgraded 

func (_DoubleLogicERC1967Upgrade *DoubleLogicERC1967UpgradeFilterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*DoubleLogicERC1967UpgradeBeaconUpgradedIterator, error)

FilterBeaconUpgraded is a free log retrieval operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e.

Solidity: event BeaconUpgraded(address indexed beacon)

func (*DoubleLogicERC1967UpgradeFilterer) FilterUpgraded 

func (_DoubleLogicERC1967Upgrade *DoubleLogicERC1967UpgradeFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*DoubleLogicERC1967UpgradeUpgradedIterator, error)

FilterUpgraded is a free log retrieval operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b.

Solidity: event Upgraded(address indexed implementation)

func (*DoubleLogicERC1967UpgradeFilterer) FilterUpgradedSecondary 

func (_DoubleLogicERC1967Upgrade *DoubleLogicERC1967UpgradeFilterer) FilterUpgradedSecondary(opts *bind.FilterOpts, implementation []common.Address) (*DoubleLogicERC1967UpgradeUpgradedSecondaryIterator, error)

FilterUpgradedSecondary is a free log retrieval operation binding the contract event 0xf7eed2a7fabbf1bec8d55ed5e785cc76622376dde5df4ff15470551e030b8134.

Solidity: event UpgradedSecondary(address indexed implementation)

func (*DoubleLogicERC1967UpgradeFilterer) ParseAdminChanged 

func (_DoubleLogicERC1967Upgrade *DoubleLogicERC1967UpgradeFilterer) ParseAdminChanged(log types.Log) (*DoubleLogicERC1967UpgradeAdminChanged, error)

ParseAdminChanged is a log parse operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f.

Solidity: event AdminChanged(address previousAdmin, address newAdmin)

func (*DoubleLogicERC1967UpgradeFilterer) ParseBeaconUpgraded 

func (_DoubleLogicERC1967Upgrade *DoubleLogicERC1967UpgradeFilterer) ParseBeaconUpgraded(log types.Log) (*DoubleLogicERC1967UpgradeBeaconUpgraded, error)

ParseBeaconUpgraded is a log parse operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e.

Solidity: event BeaconUpgraded(address indexed beacon)

func (*DoubleLogicERC1967UpgradeFilterer) ParseUpgraded 

func (_DoubleLogicERC1967Upgrade *DoubleLogicERC1967UpgradeFilterer) ParseUpgraded(log types.Log) (*DoubleLogicERC1967UpgradeUpgraded, error)

ParseUpgraded is a log parse operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b.

Solidity: event Upgraded(address indexed implementation)

func (*DoubleLogicERC1967UpgradeFilterer) ParseUpgradedSecondary 

func (_DoubleLogicERC1967Upgrade *DoubleLogicERC1967UpgradeFilterer) ParseUpgradedSecondary(log types.Log) (*DoubleLogicERC1967UpgradeUpgradedSecondary, error)

ParseUpgradedSecondary is a log parse operation binding the contract event 0xf7eed2a7fabbf1bec8d55ed5e785cc76622376dde5df4ff15470551e030b8134.

Solidity: event UpgradedSecondary(address indexed implementation)

func (*DoubleLogicERC1967UpgradeFilterer) WatchAdminChanged 

func (_DoubleLogicERC1967Upgrade *DoubleLogicERC1967UpgradeFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *DoubleLogicERC1967UpgradeAdminChanged) (event.Subscription, error)

WatchAdminChanged is a free log subscription operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f.

Solidity: event AdminChanged(address previousAdmin, address newAdmin)

func (*DoubleLogicERC1967UpgradeFilterer) WatchBeaconUpgraded 

func (_DoubleLogicERC1967Upgrade *DoubleLogicERC1967UpgradeFilterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *DoubleLogicERC1967UpgradeBeaconUpgraded, beacon []common.Address) (event.Subscription, error)

WatchBeaconUpgraded is a free log subscription operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e.

Solidity: event BeaconUpgraded(address indexed beacon)

func (*DoubleLogicERC1967UpgradeFilterer) WatchUpgraded 

func (_DoubleLogicERC1967Upgrade *DoubleLogicERC1967UpgradeFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *DoubleLogicERC1967UpgradeUpgraded, implementation []common.Address) (event.Subscription, error)

WatchUpgraded is a free log subscription operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b.

Solidity: event Upgraded(address indexed implementation)

func (*DoubleLogicERC1967UpgradeFilterer) WatchUpgradedSecondary 

func (_DoubleLogicERC1967Upgrade *DoubleLogicERC1967UpgradeFilterer) WatchUpgradedSecondary(opts *bind.WatchOpts, sink chan<- *DoubleLogicERC1967UpgradeUpgradedSecondary, implementation []common.Address) (event.Subscription, error)

WatchUpgradedSecondary is a free log subscription operation binding the contract event 0xf7eed2a7fabbf1bec8d55ed5e785cc76622376dde5df4ff15470551e030b8134.

Solidity: event UpgradedSecondary(address indexed implementation)

type DoubleLogicERC1967UpgradeRaw 

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

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

func (*DoubleLogicERC1967UpgradeRaw) Call 

func (_DoubleLogicERC1967Upgrade *DoubleLogicERC1967UpgradeRaw) 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 (*DoubleLogicERC1967UpgradeRaw) Transact 

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

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

func (*DoubleLogicERC1967UpgradeRaw) Transfer 

func (_DoubleLogicERC1967Upgrade *DoubleLogicERC1967UpgradeRaw) 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 DoubleLogicERC1967UpgradeSession 

type DoubleLogicERC1967UpgradeSession struct {
	Contract     *DoubleLogicERC1967Upgrade // 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
}

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

type DoubleLogicERC1967UpgradeTransactor 

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

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

func NewDoubleLogicERC1967UpgradeTransactor 

func NewDoubleLogicERC1967UpgradeTransactor(address common.Address, transactor bind.ContractTransactor) (*DoubleLogicERC1967UpgradeTransactor, error)

NewDoubleLogicERC1967UpgradeTransactor creates a new write-only instance of DoubleLogicERC1967Upgrade, bound to a specific deployed contract.

type DoubleLogicERC1967UpgradeTransactorRaw 

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

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

func (*DoubleLogicERC1967UpgradeTransactorRaw) Transact 

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

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

func (*DoubleLogicERC1967UpgradeTransactorRaw) Transfer 

func (_DoubleLogicERC1967Upgrade *DoubleLogicERC1967UpgradeTransactorRaw) 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 DoubleLogicERC1967UpgradeTransactorSession 

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

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

type DoubleLogicERC1967UpgradeUpgraded 

type DoubleLogicERC1967UpgradeUpgraded struct {
	Implementation common.Address
	Raw            types.Log // Blockchain specific contextual infos
}

DoubleLogicERC1967UpgradeUpgraded represents a Upgraded event raised by the DoubleLogicERC1967Upgrade contract.

type DoubleLogicERC1967UpgradeUpgradedIterator 

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

DoubleLogicERC1967UpgradeUpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the DoubleLogicERC1967Upgrade contract.

func (*DoubleLogicERC1967UpgradeUpgradedIterator) Close 

func (it *DoubleLogicERC1967UpgradeUpgradedIterator) Close() error

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

func (*DoubleLogicERC1967UpgradeUpgradedIterator) Error 

func (it *DoubleLogicERC1967UpgradeUpgradedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DoubleLogicERC1967UpgradeUpgradedIterator) Next 

func (it *DoubleLogicERC1967UpgradeUpgradedIterator) 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 DoubleLogicERC1967UpgradeUpgradedSecondary 

type DoubleLogicERC1967UpgradeUpgradedSecondary struct {
	Implementation common.Address
	Raw            types.Log // Blockchain specific contextual infos
}

DoubleLogicERC1967UpgradeUpgradedSecondary represents a UpgradedSecondary event raised by the DoubleLogicERC1967Upgrade contract.

type DoubleLogicERC1967UpgradeUpgradedSecondaryIterator 

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

DoubleLogicERC1967UpgradeUpgradedSecondaryIterator is returned from FilterUpgradedSecondary and is used to iterate over the raw logs and unpacked data for UpgradedSecondary events raised by the DoubleLogicERC1967Upgrade contract.

func (*DoubleLogicERC1967UpgradeUpgradedSecondaryIterator) Close 

func (it *DoubleLogicERC1967UpgradeUpgradedSecondaryIterator) Close() error

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

func (*DoubleLogicERC1967UpgradeUpgradedSecondaryIterator) Error 

func (it *DoubleLogicERC1967UpgradeUpgradedSecondaryIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DoubleLogicERC1967UpgradeUpgradedSecondaryIterator) Next 

func (it *DoubleLogicERC1967UpgradeUpgradedSecondaryIterator) 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 DoubleLogicUUPSUpgradeable 

type DoubleLogicUUPSUpgradeable struct {
	DoubleLogicUUPSUpgradeableCaller     // Read-only binding to the contract
	DoubleLogicUUPSUpgradeableTransactor // Write-only binding to the contract
	DoubleLogicUUPSUpgradeableFilterer   // Log filterer for contract events
}

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

func NewDoubleLogicUUPSUpgradeable 

func NewDoubleLogicUUPSUpgradeable(address common.Address, backend bind.ContractBackend) (*DoubleLogicUUPSUpgradeable, error)

NewDoubleLogicUUPSUpgradeable creates a new instance of DoubleLogicUUPSUpgradeable, bound to a specific deployed contract.

type DoubleLogicUUPSUpgradeableAdminChanged 

type DoubleLogicUUPSUpgradeableAdminChanged struct {
	PreviousAdmin common.Address
	NewAdmin      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

DoubleLogicUUPSUpgradeableAdminChanged represents a AdminChanged event raised by the DoubleLogicUUPSUpgradeable contract.

type DoubleLogicUUPSUpgradeableAdminChangedIterator 

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

DoubleLogicUUPSUpgradeableAdminChangedIterator is returned from FilterAdminChanged and is used to iterate over the raw logs and unpacked data for AdminChanged events raised by the DoubleLogicUUPSUpgradeable contract.

func (*DoubleLogicUUPSUpgradeableAdminChangedIterator) Close 

func (it *DoubleLogicUUPSUpgradeableAdminChangedIterator) Close() error

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

func (*DoubleLogicUUPSUpgradeableAdminChangedIterator) Error 

func (it *DoubleLogicUUPSUpgradeableAdminChangedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DoubleLogicUUPSUpgradeableAdminChangedIterator) Next 

func (it *DoubleLogicUUPSUpgradeableAdminChangedIterator) 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 DoubleLogicUUPSUpgradeableBeaconUpgraded 

type DoubleLogicUUPSUpgradeableBeaconUpgraded struct {
	Beacon common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

DoubleLogicUUPSUpgradeableBeaconUpgraded represents a BeaconUpgraded event raised by the DoubleLogicUUPSUpgradeable contract.

type DoubleLogicUUPSUpgradeableBeaconUpgradedIterator 

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

DoubleLogicUUPSUpgradeableBeaconUpgradedIterator is returned from FilterBeaconUpgraded and is used to iterate over the raw logs and unpacked data for BeaconUpgraded events raised by the DoubleLogicUUPSUpgradeable contract.

func (*DoubleLogicUUPSUpgradeableBeaconUpgradedIterator) Close 

func (it *DoubleLogicUUPSUpgradeableBeaconUpgradedIterator) Close() error

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

func (*DoubleLogicUUPSUpgradeableBeaconUpgradedIterator) Error 

func (it *DoubleLogicUUPSUpgradeableBeaconUpgradedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DoubleLogicUUPSUpgradeableBeaconUpgradedIterator) Next 

func (it *DoubleLogicUUPSUpgradeableBeaconUpgradedIterator) 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 DoubleLogicUUPSUpgradeableCaller 

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

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

func NewDoubleLogicUUPSUpgradeableCaller 

func NewDoubleLogicUUPSUpgradeableCaller(address common.Address, caller bind.ContractCaller) (*DoubleLogicUUPSUpgradeableCaller, error)

NewDoubleLogicUUPSUpgradeableCaller creates a new read-only instance of DoubleLogicUUPSUpgradeable, bound to a specific deployed contract.

func (*DoubleLogicUUPSUpgradeableCaller) ProxiableUUID 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableCaller) ProxiableUUID(opts *bind.CallOpts) ([32]byte, error)

ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d.

Solidity: function proxiableUUID() view returns(bytes32)

type DoubleLogicUUPSUpgradeableCallerRaw 

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

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

func (*DoubleLogicUUPSUpgradeableCallerRaw) Call 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableCallerRaw) 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 DoubleLogicUUPSUpgradeableCallerSession 

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

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

func (*DoubleLogicUUPSUpgradeableCallerSession) ProxiableUUID 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableCallerSession) ProxiableUUID() ([32]byte, error)

ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d.

Solidity: function proxiableUUID() view returns(bytes32)

type DoubleLogicUUPSUpgradeableFilterer 

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

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

func NewDoubleLogicUUPSUpgradeableFilterer 

func NewDoubleLogicUUPSUpgradeableFilterer(address common.Address, filterer bind.ContractFilterer) (*DoubleLogicUUPSUpgradeableFilterer, error)

NewDoubleLogicUUPSUpgradeableFilterer creates a new log filterer instance of DoubleLogicUUPSUpgradeable, bound to a specific deployed contract.

func (*DoubleLogicUUPSUpgradeableFilterer) FilterAdminChanged 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*DoubleLogicUUPSUpgradeableAdminChangedIterator, error)

FilterAdminChanged is a free log retrieval operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f.

Solidity: event AdminChanged(address previousAdmin, address newAdmin)

func (*DoubleLogicUUPSUpgradeableFilterer) FilterBeaconUpgraded 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableFilterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*DoubleLogicUUPSUpgradeableBeaconUpgradedIterator, error)

FilterBeaconUpgraded is a free log retrieval operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e.

Solidity: event BeaconUpgraded(address indexed beacon)

func (*DoubleLogicUUPSUpgradeableFilterer) FilterUpgraded 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*DoubleLogicUUPSUpgradeableUpgradedIterator, error)

FilterUpgraded is a free log retrieval operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b.

Solidity: event Upgraded(address indexed implementation)

func (*DoubleLogicUUPSUpgradeableFilterer) FilterUpgradedSecondary 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableFilterer) FilterUpgradedSecondary(opts *bind.FilterOpts, implementation []common.Address) (*DoubleLogicUUPSUpgradeableUpgradedSecondaryIterator, error)

FilterUpgradedSecondary is a free log retrieval operation binding the contract event 0xf7eed2a7fabbf1bec8d55ed5e785cc76622376dde5df4ff15470551e030b8134.

Solidity: event UpgradedSecondary(address indexed implementation)

func (*DoubleLogicUUPSUpgradeableFilterer) ParseAdminChanged 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableFilterer) ParseAdminChanged(log types.Log) (*DoubleLogicUUPSUpgradeableAdminChanged, error)

ParseAdminChanged is a log parse operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f.

Solidity: event AdminChanged(address previousAdmin, address newAdmin)

func (*DoubleLogicUUPSUpgradeableFilterer) ParseBeaconUpgraded 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableFilterer) ParseBeaconUpgraded(log types.Log) (*DoubleLogicUUPSUpgradeableBeaconUpgraded, error)

ParseBeaconUpgraded is a log parse operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e.

Solidity: event BeaconUpgraded(address indexed beacon)

func (*DoubleLogicUUPSUpgradeableFilterer) ParseUpgraded 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableFilterer) ParseUpgraded(log types.Log) (*DoubleLogicUUPSUpgradeableUpgraded, error)

ParseUpgraded is a log parse operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b.

Solidity: event Upgraded(address indexed implementation)

func (*DoubleLogicUUPSUpgradeableFilterer) ParseUpgradedSecondary 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableFilterer) ParseUpgradedSecondary(log types.Log) (*DoubleLogicUUPSUpgradeableUpgradedSecondary, error)

ParseUpgradedSecondary is a log parse operation binding the contract event 0xf7eed2a7fabbf1bec8d55ed5e785cc76622376dde5df4ff15470551e030b8134.

Solidity: event UpgradedSecondary(address indexed implementation)

func (*DoubleLogicUUPSUpgradeableFilterer) WatchAdminChanged 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *DoubleLogicUUPSUpgradeableAdminChanged) (event.Subscription, error)

WatchAdminChanged is a free log subscription operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f.

Solidity: event AdminChanged(address previousAdmin, address newAdmin)

func (*DoubleLogicUUPSUpgradeableFilterer) WatchBeaconUpgraded 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableFilterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *DoubleLogicUUPSUpgradeableBeaconUpgraded, beacon []common.Address) (event.Subscription, error)

WatchBeaconUpgraded is a free log subscription operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e.

Solidity: event BeaconUpgraded(address indexed beacon)

func (*DoubleLogicUUPSUpgradeableFilterer) WatchUpgraded 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *DoubleLogicUUPSUpgradeableUpgraded, implementation []common.Address) (event.Subscription, error)

WatchUpgraded is a free log subscription operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b.

Solidity: event Upgraded(address indexed implementation)

func (*DoubleLogicUUPSUpgradeableFilterer) WatchUpgradedSecondary 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableFilterer) WatchUpgradedSecondary(opts *bind.WatchOpts, sink chan<- *DoubleLogicUUPSUpgradeableUpgradedSecondary, implementation []common.Address) (event.Subscription, error)

WatchUpgradedSecondary is a free log subscription operation binding the contract event 0xf7eed2a7fabbf1bec8d55ed5e785cc76622376dde5df4ff15470551e030b8134.

Solidity: event UpgradedSecondary(address indexed implementation)

type DoubleLogicUUPSUpgradeableRaw 

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

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

func (*DoubleLogicUUPSUpgradeableRaw) Call 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableRaw) 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 (*DoubleLogicUUPSUpgradeableRaw) Transact 

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

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

func (*DoubleLogicUUPSUpgradeableRaw) Transfer 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableRaw) 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 DoubleLogicUUPSUpgradeableSession 

type DoubleLogicUUPSUpgradeableSession struct {
	Contract     *DoubleLogicUUPSUpgradeable // 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
}

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

func (*DoubleLogicUUPSUpgradeableSession) ProxiableUUID 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableSession) ProxiableUUID() ([32]byte, error)

ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d.

Solidity: function proxiableUUID() view returns(bytes32)

func (*DoubleLogicUUPSUpgradeableSession) UpgradeSecondaryTo 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableSession) UpgradeSecondaryTo(newImplementation common.Address) (*types.Transaction, error)

UpgradeSecondaryTo is a paid mutator transaction binding the contract method 0x0d40a0fd.

Solidity: function upgradeSecondaryTo(address newImplementation) returns()

func (*DoubleLogicUUPSUpgradeableSession) UpgradeSecondaryToAndCall 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableSession) UpgradeSecondaryToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error)

UpgradeSecondaryToAndCall is a paid mutator transaction binding the contract method 0x9846129a.

Solidity: function upgradeSecondaryToAndCall(address newImplementation, bytes data) payable returns()

func (*DoubleLogicUUPSUpgradeableSession) UpgradeTo 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error)

UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6.

Solidity: function upgradeTo(address newImplementation) returns()

func (*DoubleLogicUUPSUpgradeableSession) UpgradeToAndCall 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error)

UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286.

Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns()

type DoubleLogicUUPSUpgradeableTransactor 

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

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

func NewDoubleLogicUUPSUpgradeableTransactor 

func NewDoubleLogicUUPSUpgradeableTransactor(address common.Address, transactor bind.ContractTransactor) (*DoubleLogicUUPSUpgradeableTransactor, error)

NewDoubleLogicUUPSUpgradeableTransactor creates a new write-only instance of DoubleLogicUUPSUpgradeable, bound to a specific deployed contract.

func (*DoubleLogicUUPSUpgradeableTransactor) UpgradeSecondaryTo 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableTransactor) UpgradeSecondaryTo(opts *bind.TransactOpts, newImplementation common.Address) (*types.Transaction, error)

UpgradeSecondaryTo is a paid mutator transaction binding the contract method 0x0d40a0fd.

Solidity: function upgradeSecondaryTo(address newImplementation) returns()

func (*DoubleLogicUUPSUpgradeableTransactor) UpgradeSecondaryToAndCall 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableTransactor) UpgradeSecondaryToAndCall(opts *bind.TransactOpts, newImplementation common.Address, data []byte) (*types.Transaction, error)

UpgradeSecondaryToAndCall is a paid mutator transaction binding the contract method 0x9846129a.

Solidity: function upgradeSecondaryToAndCall(address newImplementation, bytes data) payable returns()

func (*DoubleLogicUUPSUpgradeableTransactor) UpgradeTo 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableTransactor) UpgradeTo(opts *bind.TransactOpts, newImplementation common.Address) (*types.Transaction, error)

UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6.

Solidity: function upgradeTo(address newImplementation) returns()

func (*DoubleLogicUUPSUpgradeableTransactor) UpgradeToAndCall 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableTransactor) UpgradeToAndCall(opts *bind.TransactOpts, newImplementation common.Address, data []byte) (*types.Transaction, error)

UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286.

Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns()

type DoubleLogicUUPSUpgradeableTransactorRaw 

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

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

func (*DoubleLogicUUPSUpgradeableTransactorRaw) Transact 

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

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

func (*DoubleLogicUUPSUpgradeableTransactorRaw) Transfer 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableTransactorRaw) 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 DoubleLogicUUPSUpgradeableTransactorSession 

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

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

func (*DoubleLogicUUPSUpgradeableTransactorSession) UpgradeSecondaryTo 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableTransactorSession) UpgradeSecondaryTo(newImplementation common.Address) (*types.Transaction, error)

UpgradeSecondaryTo is a paid mutator transaction binding the contract method 0x0d40a0fd.

Solidity: function upgradeSecondaryTo(address newImplementation) returns()

func (*DoubleLogicUUPSUpgradeableTransactorSession) UpgradeSecondaryToAndCall 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableTransactorSession) UpgradeSecondaryToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error)

UpgradeSecondaryToAndCall is a paid mutator transaction binding the contract method 0x9846129a.

Solidity: function upgradeSecondaryToAndCall(address newImplementation, bytes data) payable returns()

func (*DoubleLogicUUPSUpgradeableTransactorSession) UpgradeTo 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableTransactorSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error)

UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6.

Solidity: function upgradeTo(address newImplementation) returns()

func (*DoubleLogicUUPSUpgradeableTransactorSession) UpgradeToAndCall 

func (_DoubleLogicUUPSUpgradeable *DoubleLogicUUPSUpgradeableTransactorSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error)

UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286.

Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns()

type DoubleLogicUUPSUpgradeableUpgraded 

type DoubleLogicUUPSUpgradeableUpgraded struct {
	Implementation common.Address
	Raw            types.Log // Blockchain specific contextual infos
}

DoubleLogicUUPSUpgradeableUpgraded represents a Upgraded event raised by the DoubleLogicUUPSUpgradeable contract.

type DoubleLogicUUPSUpgradeableUpgradedIterator 

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

DoubleLogicUUPSUpgradeableUpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the DoubleLogicUUPSUpgradeable contract.

func (*DoubleLogicUUPSUpgradeableUpgradedIterator) Close 

func (it *DoubleLogicUUPSUpgradeableUpgradedIterator) Close() error

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

func (*DoubleLogicUUPSUpgradeableUpgradedIterator) Error 

func (it *DoubleLogicUUPSUpgradeableUpgradedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DoubleLogicUUPSUpgradeableUpgradedIterator) Next 

func (it *DoubleLogicUUPSUpgradeableUpgradedIterator) 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 DoubleLogicUUPSUpgradeableUpgradedSecondary 

type DoubleLogicUUPSUpgradeableUpgradedSecondary struct {
	Implementation common.Address
	Raw            types.Log // Blockchain specific contextual infos
}

DoubleLogicUUPSUpgradeableUpgradedSecondary represents a UpgradedSecondary event raised by the DoubleLogicUUPSUpgradeable contract.

type DoubleLogicUUPSUpgradeableUpgradedSecondaryIterator 

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

DoubleLogicUUPSUpgradeableUpgradedSecondaryIterator is returned from FilterUpgradedSecondary and is used to iterate over the raw logs and unpacked data for UpgradedSecondary events raised by the DoubleLogicUUPSUpgradeable contract.

func (*DoubleLogicUUPSUpgradeableUpgradedSecondaryIterator) Close 

func (it *DoubleLogicUUPSUpgradeableUpgradedSecondaryIterator) Close() error

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

func (*DoubleLogicUUPSUpgradeableUpgradedSecondaryIterator) Error 

func (it *DoubleLogicUUPSUpgradeableUpgradedSecondaryIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DoubleLogicUUPSUpgradeableUpgradedSecondaryIterator) Next 

func (it *DoubleLogicUUPSUpgradeableUpgradedSecondaryIterator) 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 GasRefundEnabled 

type GasRefundEnabled struct {
	GasRefundEnabledCaller     // Read-only binding to the contract
	GasRefundEnabledTransactor // Write-only binding to the contract
	GasRefundEnabledFilterer   // Log filterer for contract events
}

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

func NewGasRefundEnabled 

func NewGasRefundEnabled(address common.Address, backend bind.ContractBackend) (*GasRefundEnabled, error)

NewGasRefundEnabled creates a new instance of GasRefundEnabled, bound to a specific deployed contract.

type GasRefundEnabledCaller 

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

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

func NewGasRefundEnabledCaller 

func NewGasRefundEnabledCaller(address common.Address, caller bind.ContractCaller) (*GasRefundEnabledCaller, error)

NewGasRefundEnabledCaller creates a new read-only instance of GasRefundEnabled, bound to a specific deployed contract.

type GasRefundEnabledCallerRaw 

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

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

func (*GasRefundEnabledCallerRaw) Call 

func (_GasRefundEnabled *GasRefundEnabledCallerRaw) 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 GasRefundEnabledCallerSession 

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

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

type GasRefundEnabledFilterer 

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

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

func NewGasRefundEnabledFilterer 

func NewGasRefundEnabledFilterer(address common.Address, filterer bind.ContractFilterer) (*GasRefundEnabledFilterer, error)

NewGasRefundEnabledFilterer creates a new log filterer instance of GasRefundEnabled, bound to a specific deployed contract.

type GasRefundEnabledRaw 

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

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

func (*GasRefundEnabledRaw) Call 

func (_GasRefundEnabled *GasRefundEnabledRaw) 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 (*GasRefundEnabledRaw) Transact 

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

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

func (*GasRefundEnabledRaw) Transfer 

func (_GasRefundEnabled *GasRefundEnabledRaw) 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 GasRefundEnabledSession 

type GasRefundEnabledSession struct {
	Contract     *GasRefundEnabled // 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
}

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

type GasRefundEnabledTransactor 

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

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

func NewGasRefundEnabledTransactor 

func NewGasRefundEnabledTransactor(address common.Address, transactor bind.ContractTransactor) (*GasRefundEnabledTransactor, error)

NewGasRefundEnabledTransactor creates a new write-only instance of GasRefundEnabled, bound to a specific deployed contract.

type GasRefundEnabledTransactorRaw 

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

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

func (*GasRefundEnabledTransactorRaw) Transact 

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

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

func (*GasRefundEnabledTransactorRaw) Transfer 

func (_GasRefundEnabled *GasRefundEnabledTransactorRaw) 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 GasRefundEnabledTransactorSession 

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

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

type IGasRefunder 

type IGasRefunder struct {
	IGasRefunderCaller     // Read-only binding to the contract
	IGasRefunderTransactor // Write-only binding to the contract
	IGasRefunderFilterer   // Log filterer for contract events
}

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

func NewIGasRefunder 

func NewIGasRefunder(address common.Address, backend bind.ContractBackend) (*IGasRefunder, error)

NewIGasRefunder creates a new instance of IGasRefunder, bound to a specific deployed contract.

type IGasRefunderCaller 

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

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

func NewIGasRefunderCaller 

func NewIGasRefunderCaller(address common.Address, caller bind.ContractCaller) (*IGasRefunderCaller, error)

NewIGasRefunderCaller creates a new read-only instance of IGasRefunder, bound to a specific deployed contract.

type IGasRefunderCallerRaw 

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

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

func (*IGasRefunderCallerRaw) Call 

func (_IGasRefunder *IGasRefunderCallerRaw) 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 IGasRefunderCallerSession 

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

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

type IGasRefunderFilterer 

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

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

func NewIGasRefunderFilterer 

func NewIGasRefunderFilterer(address common.Address, filterer bind.ContractFilterer) (*IGasRefunderFilterer, error)

NewIGasRefunderFilterer creates a new log filterer instance of IGasRefunder, bound to a specific deployed contract.

type IGasRefunderRaw 

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

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

func (*IGasRefunderRaw) Call 

func (_IGasRefunder *IGasRefunderRaw) 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 (*IGasRefunderRaw) Transact 

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

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

func (*IGasRefunderRaw) Transfer 

func (_IGasRefunder *IGasRefunderRaw) 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 IGasRefunderSession 

type IGasRefunderSession struct {
	Contract     *IGasRefunder     // 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
}

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

func (*IGasRefunderSession) OnGasSpent 

func (_IGasRefunder *IGasRefunderSession) OnGasSpent(spender common.Address, gasUsed *big.Int, calldataSize *big.Int) (*types.Transaction, error)

OnGasSpent is a paid mutator transaction binding the contract method 0xe3db8a49.

Solidity: function onGasSpent(address spender, uint256 gasUsed, uint256 calldataSize) returns(bool success)

type IGasRefunderTransactor 

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

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

func NewIGasRefunderTransactor 

func NewIGasRefunderTransactor(address common.Address, transactor bind.ContractTransactor) (*IGasRefunderTransactor, error)

NewIGasRefunderTransactor creates a new write-only instance of IGasRefunder, bound to a specific deployed contract.

func (*IGasRefunderTransactor) OnGasSpent 

func (_IGasRefunder *IGasRefunderTransactor) OnGasSpent(opts *bind.TransactOpts, spender common.Address, gasUsed *big.Int, calldataSize *big.Int) (*types.Transaction, error)

OnGasSpent is a paid mutator transaction binding the contract method 0xe3db8a49.

Solidity: function onGasSpent(address spender, uint256 gasUsed, uint256 calldataSize) returns(bool success)

type IGasRefunderTransactorRaw 

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

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

func (*IGasRefunderTransactorRaw) Transact 

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

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

func (*IGasRefunderTransactorRaw) Transfer 

func (_IGasRefunder *IGasRefunderTransactorRaw) 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 IGasRefunderTransactorSession 

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

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

func (*IGasRefunderTransactorSession) OnGasSpent 

func (_IGasRefunder *IGasRefunderTransactorSession) OnGasSpent(spender common.Address, gasUsed *big.Int, calldataSize *big.Int) (*types.Transaction, error)

OnGasSpent is a paid mutator transaction binding the contract method 0xe3db8a49.

Solidity: function onGasSpent(address spender, uint256 gasUsed, uint256 calldataSize) returns(bool success)

type IReader4844 

type IReader4844 struct {
	IReader4844Caller     // Read-only binding to the contract
	IReader4844Transactor // Write-only binding to the contract
	IReader4844Filterer   // Log filterer for contract events
}

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

func NewIReader4844 

func NewIReader4844(address common.Address, backend bind.ContractBackend) (*IReader4844, error)

NewIReader4844 creates a new instance of IReader4844, bound to a specific deployed contract.

type IReader4844Caller 

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

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

func NewIReader4844Caller 

func NewIReader4844Caller(address common.Address, caller bind.ContractCaller) (*IReader4844Caller, error)

NewIReader4844Caller creates a new read-only instance of IReader4844, bound to a specific deployed contract.

func (*IReader4844Caller) GetBlobBaseFee 

func (_IReader4844 *IReader4844Caller) GetBlobBaseFee(opts *bind.CallOpts) (*big.Int, error)

GetBlobBaseFee is a free data retrieval call binding the contract method 0x1f6d6ef7.

Solidity: function getBlobBaseFee() view returns(uint256)

func (*IReader4844Caller) GetDataHashes 

func (_IReader4844 *IReader4844Caller) GetDataHashes(opts *bind.CallOpts) ([][32]byte, error)

GetDataHashes is a free data retrieval call binding the contract method 0xe83a2d82.

Solidity: function getDataHashes() view returns(bytes32[])

type IReader4844CallerRaw 

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

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

func (*IReader4844CallerRaw) Call 

func (_IReader4844 *IReader4844CallerRaw) 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 IReader4844CallerSession 

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

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

func (*IReader4844CallerSession) GetBlobBaseFee 

func (_IReader4844 *IReader4844CallerSession) GetBlobBaseFee() (*big.Int, error)

GetBlobBaseFee is a free data retrieval call binding the contract method 0x1f6d6ef7.

Solidity: function getBlobBaseFee() view returns(uint256)

func (*IReader4844CallerSession) GetDataHashes 

func (_IReader4844 *IReader4844CallerSession) GetDataHashes() ([][32]byte, error)

GetDataHashes is a free data retrieval call binding the contract method 0xe83a2d82.

Solidity: function getDataHashes() view returns(bytes32[])

type IReader4844Filterer 

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

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

func NewIReader4844Filterer 

func NewIReader4844Filterer(address common.Address, filterer bind.ContractFilterer) (*IReader4844Filterer, error)

NewIReader4844Filterer creates a new log filterer instance of IReader4844, bound to a specific deployed contract.

type IReader4844Raw 

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

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

func (*IReader4844Raw) Call 

func (_IReader4844 *IReader4844Raw) 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 (*IReader4844Raw) Transact 

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

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

func (*IReader4844Raw) Transfer 

func (_IReader4844 *IReader4844Raw) 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 IReader4844Session 

type IReader4844Session struct {
	Contract     *IReader4844      // 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
}

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

func (*IReader4844Session) GetBlobBaseFee 

func (_IReader4844 *IReader4844Session) GetBlobBaseFee() (*big.Int, error)

GetBlobBaseFee is a free data retrieval call binding the contract method 0x1f6d6ef7.

Solidity: function getBlobBaseFee() view returns(uint256)

func (*IReader4844Session) GetDataHashes 

func (_IReader4844 *IReader4844Session) GetDataHashes() ([][32]byte, error)

GetDataHashes is a free data retrieval call binding the contract method 0xe83a2d82.

Solidity: function getDataHashes() view returns(bytes32[])

type IReader4844Transactor 

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

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

func NewIReader4844Transactor 

func NewIReader4844Transactor(address common.Address, transactor bind.ContractTransactor) (*IReader4844Transactor, error)

NewIReader4844Transactor creates a new write-only instance of IReader4844, bound to a specific deployed contract.

type IReader4844TransactorRaw 

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

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

func (*IReader4844TransactorRaw) Transact 

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

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

func (*IReader4844TransactorRaw) Transfer 

func (_IReader4844 *IReader4844TransactorRaw) 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 IReader4844TransactorSession 

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

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

type MerkleLib 

type MerkleLib struct {
	MerkleLibCaller     // Read-only binding to the contract
	MerkleLibTransactor // Write-only binding to the contract
	MerkleLibFilterer   // Log filterer for contract events
}

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

func DeployMerkleLib 

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

DeployMerkleLib deploys a new Ethereum contract, binding an instance of MerkleLib to it.

func NewMerkleLib 

func NewMerkleLib(address common.Address, backend bind.ContractBackend) (*MerkleLib, error)

NewMerkleLib creates a new instance of MerkleLib, bound to a specific deployed contract.

type MerkleLibCaller 

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

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

func NewMerkleLibCaller 

func NewMerkleLibCaller(address common.Address, caller bind.ContractCaller) (*MerkleLibCaller, error)

NewMerkleLibCaller creates a new read-only instance of MerkleLib, bound to a specific deployed contract.

type MerkleLibCallerRaw 

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

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

func (*MerkleLibCallerRaw) Call 

func (_MerkleLib *MerkleLibCallerRaw) 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 MerkleLibCallerSession 

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

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

type MerkleLibFilterer 

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

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

func NewMerkleLibFilterer 

func NewMerkleLibFilterer(address common.Address, filterer bind.ContractFilterer) (*MerkleLibFilterer, error)

NewMerkleLibFilterer creates a new log filterer instance of MerkleLib, bound to a specific deployed contract.

type MerkleLibRaw 

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

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

func (*MerkleLibRaw) Call 

func (_MerkleLib *MerkleLibRaw) 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 (*MerkleLibRaw) Transact 

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

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

func (*MerkleLibRaw) Transfer 

func (_MerkleLib *MerkleLibRaw) 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 MerkleLibSession 

type MerkleLibSession struct {
	Contract     *MerkleLib        // 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
}

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

type MerkleLibTransactor 

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

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

func NewMerkleLibTransactor 

func NewMerkleLibTransactor(address common.Address, transactor bind.ContractTransactor) (*MerkleLibTransactor, error)

NewMerkleLibTransactor creates a new write-only instance of MerkleLib, bound to a specific deployed contract.

type MerkleLibTransactorRaw 

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

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

func (*MerkleLibTransactorRaw) Transact 

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

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

func (*MerkleLibTransactorRaw) Transfer 

func (_MerkleLib *MerkleLibTransactorRaw) 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 MerkleLibTransactorSession 

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

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

type UUPSNotUpgradeable 

type UUPSNotUpgradeable struct {
	UUPSNotUpgradeableCaller     // Read-only binding to the contract
	UUPSNotUpgradeableTransactor // Write-only binding to the contract
	UUPSNotUpgradeableFilterer   // Log filterer for contract events
}

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

func NewUUPSNotUpgradeable 

func NewUUPSNotUpgradeable(address common.Address, backend bind.ContractBackend) (*UUPSNotUpgradeable, error)

NewUUPSNotUpgradeable creates a new instance of UUPSNotUpgradeable, bound to a specific deployed contract.

type UUPSNotUpgradeableAdminChanged 

type UUPSNotUpgradeableAdminChanged struct {
	PreviousAdmin common.Address
	NewAdmin      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

UUPSNotUpgradeableAdminChanged represents a AdminChanged event raised by the UUPSNotUpgradeable contract.

type UUPSNotUpgradeableAdminChangedIterator 

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

UUPSNotUpgradeableAdminChangedIterator is returned from FilterAdminChanged and is used to iterate over the raw logs and unpacked data for AdminChanged events raised by the UUPSNotUpgradeable contract.

func (*UUPSNotUpgradeableAdminChangedIterator) Close 

func (it *UUPSNotUpgradeableAdminChangedIterator) Close() error

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

func (*UUPSNotUpgradeableAdminChangedIterator) Error 

func (it *UUPSNotUpgradeableAdminChangedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*UUPSNotUpgradeableAdminChangedIterator) Next 

func (it *UUPSNotUpgradeableAdminChangedIterator) 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 UUPSNotUpgradeableBeaconUpgraded 

type UUPSNotUpgradeableBeaconUpgraded struct {
	Beacon common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

UUPSNotUpgradeableBeaconUpgraded represents a BeaconUpgraded event raised by the UUPSNotUpgradeable contract.

type UUPSNotUpgradeableBeaconUpgradedIterator 

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

UUPSNotUpgradeableBeaconUpgradedIterator is returned from FilterBeaconUpgraded and is used to iterate over the raw logs and unpacked data for BeaconUpgraded events raised by the UUPSNotUpgradeable contract.

func (*UUPSNotUpgradeableBeaconUpgradedIterator) Close 

func (it *UUPSNotUpgradeableBeaconUpgradedIterator) Close() error

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

func (*UUPSNotUpgradeableBeaconUpgradedIterator) Error 

func (it *UUPSNotUpgradeableBeaconUpgradedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*UUPSNotUpgradeableBeaconUpgradedIterator) Next 

func (it *UUPSNotUpgradeableBeaconUpgradedIterator) 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 UUPSNotUpgradeableCaller 

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

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

func NewUUPSNotUpgradeableCaller 

func NewUUPSNotUpgradeableCaller(address common.Address, caller bind.ContractCaller) (*UUPSNotUpgradeableCaller, error)

NewUUPSNotUpgradeableCaller creates a new read-only instance of UUPSNotUpgradeable, bound to a specific deployed contract.

func (*UUPSNotUpgradeableCaller) ProxiableUUID 

func (_UUPSNotUpgradeable *UUPSNotUpgradeableCaller) ProxiableUUID(opts *bind.CallOpts) ([32]byte, error)

ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d.

Solidity: function proxiableUUID() view returns(bytes32)

type UUPSNotUpgradeableCallerRaw 

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

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

func (*UUPSNotUpgradeableCallerRaw) Call 

func (_UUPSNotUpgradeable *UUPSNotUpgradeableCallerRaw) 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 UUPSNotUpgradeableCallerSession 

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

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

func (*UUPSNotUpgradeableCallerSession) ProxiableUUID 

func (_UUPSNotUpgradeable *UUPSNotUpgradeableCallerSession) ProxiableUUID() ([32]byte, error)

ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d.

Solidity: function proxiableUUID() view returns(bytes32)

type UUPSNotUpgradeableFilterer 

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

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

func NewUUPSNotUpgradeableFilterer 

func NewUUPSNotUpgradeableFilterer(address common.Address, filterer bind.ContractFilterer) (*UUPSNotUpgradeableFilterer, error)

NewUUPSNotUpgradeableFilterer creates a new log filterer instance of UUPSNotUpgradeable, bound to a specific deployed contract.

func (*UUPSNotUpgradeableFilterer) FilterAdminChanged 

func (_UUPSNotUpgradeable *UUPSNotUpgradeableFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*UUPSNotUpgradeableAdminChangedIterator, error)

FilterAdminChanged is a free log retrieval operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f.

Solidity: event AdminChanged(address previousAdmin, address newAdmin)

func (*UUPSNotUpgradeableFilterer) FilterBeaconUpgraded 

func (_UUPSNotUpgradeable *UUPSNotUpgradeableFilterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*UUPSNotUpgradeableBeaconUpgradedIterator, error)

FilterBeaconUpgraded is a free log retrieval operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e.

Solidity: event BeaconUpgraded(address indexed beacon)

func (*UUPSNotUpgradeableFilterer) FilterUpgraded 

func (_UUPSNotUpgradeable *UUPSNotUpgradeableFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*UUPSNotUpgradeableUpgradedIterator, error)

FilterUpgraded is a free log retrieval operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b.

Solidity: event Upgraded(address indexed implementation)

func (*UUPSNotUpgradeableFilterer) FilterUpgradedSecondary 

func (_UUPSNotUpgradeable *UUPSNotUpgradeableFilterer) FilterUpgradedSecondary(opts *bind.FilterOpts, implementation []common.Address) (*UUPSNotUpgradeableUpgradedSecondaryIterator, error)

FilterUpgradedSecondary is a free log retrieval operation binding the contract event 0xf7eed2a7fabbf1bec8d55ed5e785cc76622376dde5df4ff15470551e030b8134.

Solidity: event UpgradedSecondary(address indexed implementation)

func (*UUPSNotUpgradeableFilterer) ParseAdminChanged 

func (_UUPSNotUpgradeable *UUPSNotUpgradeableFilterer) ParseAdminChanged(log types.Log) (*UUPSNotUpgradeableAdminChanged, error)

ParseAdminChanged is a log parse operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f.

Solidity: event AdminChanged(address previousAdmin, address newAdmin)

func (*UUPSNotUpgradeableFilterer) ParseBeaconUpgraded 

func (_UUPSNotUpgradeable *UUPSNotUpgradeableFilterer) ParseBeaconUpgraded(log types.Log) (*UUPSNotUpgradeableBeaconUpgraded, error)

ParseBeaconUpgraded is a log parse operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e.

Solidity: event BeaconUpgraded(address indexed beacon)

func (*UUPSNotUpgradeableFilterer) ParseUpgraded 

func (_UUPSNotUpgradeable *UUPSNotUpgradeableFilterer) ParseUpgraded(log types.Log) (*UUPSNotUpgradeableUpgraded, error)

ParseUpgraded is a log parse operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b.

Solidity: event Upgraded(address indexed implementation)

func (*UUPSNotUpgradeableFilterer) ParseUpgradedSecondary 

func (_UUPSNotUpgradeable *UUPSNotUpgradeableFilterer) ParseUpgradedSecondary(log types.Log) (*UUPSNotUpgradeableUpgradedSecondary, error)

ParseUpgradedSecondary is a log parse operation binding the contract event 0xf7eed2a7fabbf1bec8d55ed5e785cc76622376dde5df4ff15470551e030b8134.

Solidity: event UpgradedSecondary(address indexed implementation)

func (*UUPSNotUpgradeableFilterer) WatchAdminChanged 

func (_UUPSNotUpgradeable *UUPSNotUpgradeableFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *UUPSNotUpgradeableAdminChanged) (event.Subscription, error)

WatchAdminChanged is a free log subscription operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f.

Solidity: event AdminChanged(address previousAdmin, address newAdmin)

func (*UUPSNotUpgradeableFilterer) WatchBeaconUpgraded 

func (_UUPSNotUpgradeable *UUPSNotUpgradeableFilterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *UUPSNotUpgradeableBeaconUpgraded, beacon []common.Address) (event.Subscription, error)

WatchBeaconUpgraded is a free log subscription operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e.

Solidity: event BeaconUpgraded(address indexed beacon)

func (*UUPSNotUpgradeableFilterer) WatchUpgraded 

func (_UUPSNotUpgradeable *UUPSNotUpgradeableFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *UUPSNotUpgradeableUpgraded, implementation []common.Address) (event.Subscription, error)

WatchUpgraded is a free log subscription operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b.

Solidity: event Upgraded(address indexed implementation)

func (*UUPSNotUpgradeableFilterer) WatchUpgradedSecondary 

func (_UUPSNotUpgradeable *UUPSNotUpgradeableFilterer) WatchUpgradedSecondary(opts *bind.WatchOpts, sink chan<- *UUPSNotUpgradeableUpgradedSecondary, implementation []common.Address) (event.Subscription, error)

WatchUpgradedSecondary is a free log subscription operation binding the contract event 0xf7eed2a7fabbf1bec8d55ed5e785cc76622376dde5df4ff15470551e030b8134.

Solidity: event UpgradedSecondary(address indexed implementation)

type UUPSNotUpgradeableRaw 

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

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

func (*UUPSNotUpgradeableRaw) Call 

func (_UUPSNotUpgradeable *UUPSNotUpgradeableRaw) 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 (*UUPSNotUpgradeableRaw) Transact 

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

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

func (*UUPSNotUpgradeableRaw) Transfer 

func (_UUPSNotUpgradeable *UUPSNotUpgradeableRaw) 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 UUPSNotUpgradeableSession 

type UUPSNotUpgradeableSession struct {
	Contract     *UUPSNotUpgradeable // 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
}

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

func (*UUPSNotUpgradeableSession) ProxiableUUID 

func (_UUPSNotUpgradeable *UUPSNotUpgradeableSession) ProxiableUUID() ([32]byte, error)

ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d.

Solidity: function proxiableUUID() view returns(bytes32)

type UUPSNotUpgradeableTransactor 

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

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

func NewUUPSNotUpgradeableTransactor 

func NewUUPSNotUpgradeableTransactor(address common.Address, transactor bind.ContractTransactor) (*UUPSNotUpgradeableTransactor, error)

NewUUPSNotUpgradeableTransactor creates a new write-only instance of UUPSNotUpgradeable, bound to a specific deployed contract.

type UUPSNotUpgradeableTransactorRaw 

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

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

func (*UUPSNotUpgradeableTransactorRaw) Transact 

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

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

func (*UUPSNotUpgradeableTransactorRaw) Transfer 

func (_UUPSNotUpgradeable *UUPSNotUpgradeableTransactorRaw) 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 UUPSNotUpgradeableTransactorSession 

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

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

type UUPSNotUpgradeableUpgraded 

type UUPSNotUpgradeableUpgraded struct {
	Implementation common.Address
	Raw            types.Log // Blockchain specific contextual infos
}

UUPSNotUpgradeableUpgraded represents a Upgraded event raised by the UUPSNotUpgradeable contract.

type UUPSNotUpgradeableUpgradedIterator 

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

UUPSNotUpgradeableUpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the UUPSNotUpgradeable contract.

func (*UUPSNotUpgradeableUpgradedIterator) Close 

func (it *UUPSNotUpgradeableUpgradedIterator) Close() error

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

func (*UUPSNotUpgradeableUpgradedIterator) Error 

func (it *UUPSNotUpgradeableUpgradedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*UUPSNotUpgradeableUpgradedIterator) Next 

func (it *UUPSNotUpgradeableUpgradedIterator) 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 UUPSNotUpgradeableUpgradedSecondary 

type UUPSNotUpgradeableUpgradedSecondary struct {
	Implementation common.Address
	Raw            types.Log // Blockchain specific contextual infos
}

UUPSNotUpgradeableUpgradedSecondary represents a UpgradedSecondary event raised by the UUPSNotUpgradeable contract.

type UUPSNotUpgradeableUpgradedSecondaryIterator 

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

UUPSNotUpgradeableUpgradedSecondaryIterator is returned from FilterUpgradedSecondary and is used to iterate over the raw logs and unpacked data for UpgradedSecondary events raised by the UUPSNotUpgradeable contract.

func (*UUPSNotUpgradeableUpgradedSecondaryIterator) Close 

func (it *UUPSNotUpgradeableUpgradedSecondaryIterator) Close() error

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

func (*UUPSNotUpgradeableUpgradedSecondaryIterator) Error 

func (it *UUPSNotUpgradeableUpgradedSecondaryIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*UUPSNotUpgradeableUpgradedSecondaryIterator) Next 

func (it *UUPSNotUpgradeableUpgradedSecondaryIterator) 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.

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.