channel

package
v4.0.21 Latest Latest
Warning

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

 Go to latest Published: Dec 20, 2024 License: Apache-2.0 Imports: 9 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var ProtoChannelABI = ProtoChannelMetaData.ABI

ProtoChannelABI is the input ABI used to generate the binding from. Deprecated: Use ProtoChannelMetaData.ABI instead.

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

ProtoChannelMetaData contains all meta data concerning the ProtoChannel contract.

View Source 
var ProtoCounterpartyABI = ProtoCounterpartyMetaData.ABI

ProtoCounterpartyABI is the input ABI used to generate the binding from. Deprecated: Use ProtoCounterpartyMetaData.ABI instead.

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

ProtoCounterpartyMetaData contains all meta data concerning the ProtoCounterparty contract.

Functions

This section is empty.

Types

type ProtoChannel 

type ProtoChannel struct {
	ProtoChannelCaller     // Read-only binding to the contract
	ProtoChannelTransactor // Write-only binding to the contract
	ProtoChannelFilterer   // Log filterer for contract events
}

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

func NewProtoChannel 

func NewProtoChannel(address common.Address, backend bind.ContractBackend) (*ProtoChannel, error)

NewProtoChannel creates a new instance of ProtoChannel, bound to a specific deployed contract.

type ProtoChannelCaller 

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

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

func NewProtoChannelCaller 

func NewProtoChannelCaller(address common.Address, caller bind.ContractCaller) (*ProtoChannelCaller, error)

NewProtoChannelCaller creates a new read-only instance of ProtoChannel, bound to a specific deployed contract.

type ProtoChannelCallerRaw 

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

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

func (*ProtoChannelCallerRaw) Call 

func (_ProtoChannel *ProtoChannelCallerRaw) 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 ProtoChannelCallerSession 

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

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

type ProtoChannelFilterer 

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

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

func NewProtoChannelFilterer 

func NewProtoChannelFilterer(address common.Address, filterer bind.ContractFilterer) (*ProtoChannelFilterer, error)

NewProtoChannelFilterer creates a new log filterer instance of ProtoChannel, bound to a specific deployed contract.

type ProtoChannelRaw 

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

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

func (*ProtoChannelRaw) Call 

func (_ProtoChannel *ProtoChannelRaw) 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 (*ProtoChannelRaw) Transact 

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

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

func (*ProtoChannelRaw) Transfer 

func (_ProtoChannel *ProtoChannelRaw) 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 ProtoChannelSession 

type ProtoChannelSession struct {
	Contract     *ProtoChannel     // 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
}

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

type ProtoChannelTransactor 

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

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

func NewProtoChannelTransactor 

func NewProtoChannelTransactor(address common.Address, transactor bind.ContractTransactor) (*ProtoChannelTransactor, error)

NewProtoChannelTransactor creates a new write-only instance of ProtoChannel, bound to a specific deployed contract.

type ProtoChannelTransactorRaw 

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

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

func (*ProtoChannelTransactorRaw) Transact 

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

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

func (*ProtoChannelTransactorRaw) Transfer 

func (_ProtoChannel *ProtoChannelTransactorRaw) 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 ProtoChannelTransactorSession 

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

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

type ProtoCounterparty 

type ProtoCounterparty struct {
	ProtoCounterpartyCaller     // Read-only binding to the contract
	ProtoCounterpartyTransactor // Write-only binding to the contract
	ProtoCounterpartyFilterer   // Log filterer for contract events
}

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

func NewProtoCounterparty 

func NewProtoCounterparty(address common.Address, backend bind.ContractBackend) (*ProtoCounterparty, error)

NewProtoCounterparty creates a new instance of ProtoCounterparty, bound to a specific deployed contract.

type ProtoCounterpartyCaller 

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

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

func NewProtoCounterpartyCaller 

func NewProtoCounterpartyCaller(address common.Address, caller bind.ContractCaller) (*ProtoCounterpartyCaller, error)

NewProtoCounterpartyCaller creates a new read-only instance of ProtoCounterparty, bound to a specific deployed contract.

type ProtoCounterpartyCallerRaw 

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

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

func (*ProtoCounterpartyCallerRaw) Call 

func (_ProtoCounterparty *ProtoCounterpartyCallerRaw) 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 ProtoCounterpartyCallerSession 

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

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

type ProtoCounterpartyFilterer 

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

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

func NewProtoCounterpartyFilterer 

func NewProtoCounterpartyFilterer(address common.Address, filterer bind.ContractFilterer) (*ProtoCounterpartyFilterer, error)

NewProtoCounterpartyFilterer creates a new log filterer instance of ProtoCounterparty, bound to a specific deployed contract.

type ProtoCounterpartyRaw 

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

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

func (*ProtoCounterpartyRaw) Call 

func (_ProtoCounterparty *ProtoCounterpartyRaw) 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 (*ProtoCounterpartyRaw) Transact 

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

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

func (*ProtoCounterpartyRaw) Transfer 

func (_ProtoCounterparty *ProtoCounterpartyRaw) 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 ProtoCounterpartySession 

type ProtoCounterpartySession struct {
	Contract     *ProtoCounterparty // 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
}

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

type ProtoCounterpartyTransactor 

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

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

func NewProtoCounterpartyTransactor 

func NewProtoCounterpartyTransactor(address common.Address, transactor bind.ContractTransactor) (*ProtoCounterpartyTransactor, error)

NewProtoCounterpartyTransactor creates a new write-only instance of ProtoCounterparty, bound to a specific deployed contract.

type ProtoCounterpartyTransactorRaw 

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

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

func (*ProtoCounterpartyTransactorRaw) Transact 

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

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

func (*ProtoCounterpartyTransactorRaw) Transfer 

func (_ProtoCounterparty *ProtoCounterpartyTransactorRaw) 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 ProtoCounterpartyTransactorSession 

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

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

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.