contract

package
v0.0.0-...-7037f4e Latest Latest
Warning

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

 Go to latest Published: Jul 25, 2021 License: GPL-3.0 Imports: 5 Imported by: 0

Documentation

Index

Constants

View Source 
const Base1ABI = "[{\"inputs\":[],\"name\":\"foo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"

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

View Source 
const Base1Bin = `` /* 278-byte string literal not displayed */

Base1Bin is the compiled bytecode used for deploying new contracts.

View Source 
const Base2ABI = "[{\"inputs\":[],\"name\":\"foo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"

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

View Source 
const Base2Bin = `` /* 278-byte string literal not displayed */

Base2Bin is the compiled bytecode used for deploying new contracts.

View Source 
const InheritedABI = "[{\"inputs\":[],\"name\":\"foo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"

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

View Source 
const InheritedBin = `` /* 278-byte string literal not displayed */

InheritedBin is the compiled bytecode used for deploying new contracts.

Variables

This section is empty.

Functions

This section is empty.

Types

type Base1 

type Base1 struct {
	Base1Caller     // Read-only binding to the contract
	Base1Transactor // Write-only binding to the contract
	Base1Filterer   // Log filterer for contract events
}

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

func DeployBase1 

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

DeployBase1 deploys a new Ethereum contract, binding an instance of Base1 to it.

func NewBase1 

func NewBase1(address common.Address, backend bind.ContractBackend) (*Base1, error)

NewBase1 creates a new instance of Base1, bound to a specific deployed contract.

type Base1Caller 

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

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

func NewBase1Caller 

func NewBase1Caller(address common.Address, caller bind.ContractCaller) (*Base1Caller, error)

NewBase1Caller creates a new read-only instance of Base1, bound to a specific deployed contract.

type Base1CallerRaw 

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

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

func (*Base1CallerRaw) Call 

func (_Base1 *Base1CallerRaw) 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 Base1CallerSession 

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

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

type Base1Filterer 

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

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

func NewBase1Filterer 

func NewBase1Filterer(address common.Address, filterer bind.ContractFilterer) (*Base1Filterer, error)

NewBase1Filterer creates a new log filterer instance of Base1, bound to a specific deployed contract.

type Base1Raw 

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

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

func (*Base1Raw) Call 

func (_Base1 *Base1Raw) 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 (*Base1Raw) Transact 

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

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

func (*Base1Raw) Transfer 

func (_Base1 *Base1Raw) 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 Base1Session 

type Base1Session struct {
	Contract     *Base1            // 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
}

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

func (*Base1Session) Foo 

func (_Base1 *Base1Session) Foo() (*types.Transaction, error)

Foo is a paid mutator transaction binding the contract method 0xc2985578.

Solidity: function foo() returns()

type Base1Transactor 

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

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

func NewBase1Transactor 

func NewBase1Transactor(address common.Address, transactor bind.ContractTransactor) (*Base1Transactor, error)

NewBase1Transactor creates a new write-only instance of Base1, bound to a specific deployed contract.

func (*Base1Transactor) Foo 

func (_Base1 *Base1Transactor) Foo(opts *bind.TransactOpts) (*types.Transaction, error)

Foo is a paid mutator transaction binding the contract method 0xc2985578.

Solidity: function foo() returns()

type Base1TransactorRaw 

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

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

func (*Base1TransactorRaw) Transact 

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

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

func (*Base1TransactorRaw) Transfer 

func (_Base1 *Base1TransactorRaw) 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 Base1TransactorSession 

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

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

func (*Base1TransactorSession) Foo 

func (_Base1 *Base1TransactorSession) Foo() (*types.Transaction, error)

Foo is a paid mutator transaction binding the contract method 0xc2985578.

Solidity: function foo() returns()

type Base2 

type Base2 struct {
	Base2Caller     // Read-only binding to the contract
	Base2Transactor // Write-only binding to the contract
	Base2Filterer   // Log filterer for contract events
}

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

func DeployBase2 

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

DeployBase2 deploys a new Ethereum contract, binding an instance of Base2 to it.

func NewBase2 

func NewBase2(address common.Address, backend bind.ContractBackend) (*Base2, error)

NewBase2 creates a new instance of Base2, bound to a specific deployed contract.

type Base2Caller 

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

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

func NewBase2Caller 

func NewBase2Caller(address common.Address, caller bind.ContractCaller) (*Base2Caller, error)

NewBase2Caller creates a new read-only instance of Base2, bound to a specific deployed contract.

type Base2CallerRaw 

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

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

func (*Base2CallerRaw) Call 

func (_Base2 *Base2CallerRaw) 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 Base2CallerSession 

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

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

type Base2Filterer 

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

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

func NewBase2Filterer 

func NewBase2Filterer(address common.Address, filterer bind.ContractFilterer) (*Base2Filterer, error)

NewBase2Filterer creates a new log filterer instance of Base2, bound to a specific deployed contract.

type Base2Raw 

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

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

func (*Base2Raw) Call 

func (_Base2 *Base2Raw) 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 (*Base2Raw) Transact 

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

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

func (*Base2Raw) Transfer 

func (_Base2 *Base2Raw) 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 Base2Session 

type Base2Session struct {
	Contract     *Base2            // 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
}

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

func (*Base2Session) Foo 

func (_Base2 *Base2Session) Foo() (*types.Transaction, error)

Foo is a paid mutator transaction binding the contract method 0xc2985578.

Solidity: function foo() returns()

type Base2Transactor 

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

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

func NewBase2Transactor 

func NewBase2Transactor(address common.Address, transactor bind.ContractTransactor) (*Base2Transactor, error)

NewBase2Transactor creates a new write-only instance of Base2, bound to a specific deployed contract.

func (*Base2Transactor) Foo 

func (_Base2 *Base2Transactor) Foo(opts *bind.TransactOpts) (*types.Transaction, error)

Foo is a paid mutator transaction binding the contract method 0xc2985578.

Solidity: function foo() returns()

type Base2TransactorRaw 

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

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

func (*Base2TransactorRaw) Transact 

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

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

func (*Base2TransactorRaw) Transfer 

func (_Base2 *Base2TransactorRaw) 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 Base2TransactorSession 

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

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

func (*Base2TransactorSession) Foo 

func (_Base2 *Base2TransactorSession) Foo() (*types.Transaction, error)

Foo is a paid mutator transaction binding the contract method 0xc2985578.

Solidity: function foo() returns()

type Inherited 

type Inherited struct {
	InheritedCaller     // Read-only binding to the contract
	InheritedTransactor // Write-only binding to the contract
	InheritedFilterer   // Log filterer for contract events
}

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

func DeployInherited 

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

DeployInherited deploys a new Ethereum contract, binding an instance of Inherited to it.

func NewInherited 

func NewInherited(address common.Address, backend bind.ContractBackend) (*Inherited, error)

NewInherited creates a new instance of Inherited, bound to a specific deployed contract.

type InheritedCaller 

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

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

func NewInheritedCaller 

func NewInheritedCaller(address common.Address, caller bind.ContractCaller) (*InheritedCaller, error)

NewInheritedCaller creates a new read-only instance of Inherited, bound to a specific deployed contract.

type InheritedCallerRaw 

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

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

func (*InheritedCallerRaw) Call 

func (_Inherited *InheritedCallerRaw) 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 InheritedCallerSession 

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

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

type InheritedFilterer 

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

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

func NewInheritedFilterer 

func NewInheritedFilterer(address common.Address, filterer bind.ContractFilterer) (*InheritedFilterer, error)

NewInheritedFilterer creates a new log filterer instance of Inherited, bound to a specific deployed contract.

type InheritedRaw 

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

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

func (*InheritedRaw) Call 

func (_Inherited *InheritedRaw) 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 (*InheritedRaw) Transact 

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

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

func (*InheritedRaw) Transfer 

func (_Inherited *InheritedRaw) 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 InheritedSession 

type InheritedSession struct {
	Contract     *Inherited        // 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
}

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

func (*InheritedSession) Foo 

func (_Inherited *InheritedSession) Foo() (*types.Transaction, error)

Foo is a paid mutator transaction binding the contract method 0xc2985578.

Solidity: function foo() returns()

type InheritedTransactor 

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

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

func NewInheritedTransactor 

func NewInheritedTransactor(address common.Address, transactor bind.ContractTransactor) (*InheritedTransactor, error)

NewInheritedTransactor creates a new write-only instance of Inherited, bound to a specific deployed contract.

func (*InheritedTransactor) Foo 

func (_Inherited *InheritedTransactor) Foo(opts *bind.TransactOpts) (*types.Transaction, error)

Foo is a paid mutator transaction binding the contract method 0xc2985578.

Solidity: function foo() returns()

type InheritedTransactorRaw 

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

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

func (*InheritedTransactorRaw) Transact 

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

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

func (*InheritedTransactorRaw) Transfer 

func (_Inherited *InheritedTransactorRaw) 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 InheritedTransactorSession 

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

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

func (*InheritedTransactorSession) Foo 

func (_Inherited *InheritedTransactorSession) Foo() (*types.Transaction, error)

Foo is a paid mutator transaction binding the contract method 0xc2985578.

Solidity: function foo() returns()

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.