diamondabi

Documentation

Index

• Variables
• type Diamond
  • func NewDiamond(address common.Address, backend bind.ContractBackend) (*Diamond, error)
• type DiamondCaller
  • func NewDiamondCaller(address common.Address, caller bind.ContractCaller) (*DiamondCaller, error)
• type DiamondCallerRaw
  • func (_Diamond *DiamondCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error
• type DiamondCallerSession
• type DiamondFilterer
  • func NewDiamondFilterer(address common.Address, filterer bind.ContractFilterer) (*DiamondFilterer, error)
• type DiamondRaw
  • func (_Diamond *DiamondRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error
  • func (_Diamond *DiamondRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)
  • func (_Diamond *DiamondRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)
• type DiamondSession
  • func (_Diamond *DiamondSession) Fallback(calldata []byte) (*types.Transaction, error)
  • func (_Diamond *DiamondSession) Receive() (*types.Transaction, error)
• type DiamondTransactor
  • func NewDiamondTransactor(address common.Address, transactor bind.ContractTransactor) (*DiamondTransactor, error)
  • func (_Diamond *DiamondTransactor) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error)
  • func (_Diamond *DiamondTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)
• type DiamondTransactorRaw
  • func (_Diamond *DiamondTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)
  • func (_Diamond *DiamondTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)
• type DiamondTransactorSession
  • func (_Diamond *DiamondTransactorSession) Fallback(calldata []byte) (*types.Transaction, error)
  • func (_Diamond *DiamondTransactorSession) Receive() (*types.Transaction, error)

Variables

var DiamondABI = DiamondMetaData.ABI

DiamondABI is the input ABI used to generate the binding from. Deprecated: Use DiamondMetaData.ABI instead.

var DiamondMetaData = &bind.MetaData{
	ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_contractOwner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_diamondCutFacet\",\"type\":\"address\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}]",
}

DiamondMetaData contains all meta data concerning the Diamond contract.

Types

type Diamond

type Diamond struct {
	DiamondCaller     // Read-only binding to the contract
	DiamondTransactor // Write-only binding to the contract
	DiamondFilterer   // Log filterer for contract events
}

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

func NewDiamond

func NewDiamond(address common.Address, backend bind.ContractBackend) (*Diamond, error)

NewDiamond creates a new instance of Diamond, bound to a specific deployed contract.

type DiamondCaller

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

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

func NewDiamondCaller

func NewDiamondCaller(address common.Address, caller bind.ContractCaller) (*DiamondCaller, error)

NewDiamondCaller creates a new read-only instance of Diamond, bound to a specific deployed contract.

type DiamondCallerRaw

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

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

func (*DiamondCallerRaw) Call

func (_Diamond *DiamondCallerRaw) 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 DiamondCallerSession

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

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

type DiamondFilterer

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

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

func NewDiamondFilterer

func NewDiamondFilterer(address common.Address, filterer bind.ContractFilterer) (*DiamondFilterer, error)

NewDiamondFilterer creates a new log filterer instance of Diamond, bound to a specific deployed contract.

type DiamondRaw

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

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

func (*DiamondRaw) Call

func (_Diamond *DiamondRaw) 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 (*DiamondRaw) Transact

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

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

func (*DiamondRaw) Transfer

func (_Diamond *DiamondRaw) 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 DiamondSession

type DiamondSession struct {
	Contract     *Diamond          // 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
}

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

func (*DiamondSession) Fallback

func (_Diamond *DiamondSession) Fallback(calldata []byte) (*types.Transaction, error)

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

Solidity: fallback() payable returns()

func (*DiamondSession) Receive

func (_Diamond *DiamondSession) Receive() (*types.Transaction, error)

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

Solidity: receive() payable returns()

type DiamondTransactor

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

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

func NewDiamondTransactor

func NewDiamondTransactor(address common.Address, transactor bind.ContractTransactor) (*DiamondTransactor, error)

NewDiamondTransactor creates a new write-only instance of Diamond, bound to a specific deployed contract.

func (*DiamondTransactor) Fallback

func (_Diamond *DiamondTransactor) 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 (*DiamondTransactor) Receive

func (_Diamond *DiamondTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

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

Solidity: receive() payable returns()

type DiamondTransactorRaw

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

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

func (*DiamondTransactorRaw) Transact

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

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

func (*DiamondTransactorRaw) Transfer

func (_Diamond *DiamondTransactorRaw) 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 DiamondTransactorSession

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

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

func (*DiamondTransactorSession) Fallback

func (_Diamond *DiamondTransactorSession) Fallback(calldata []byte) (*types.Transaction, error)

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

Solidity: fallback() payable returns()

func (*DiamondTransactorSession) Receive

func (_Diamond *DiamondTransactorSession) Receive() (*types.Transaction, error)

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

Solidity: receive() payable returns()