contract

package
v2.1.6-beta.2+incompat... Latest Latest
Warning

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

 Go to latest Published: Sep 18, 2020 License: GPL-3.0 Imports: 5 Imported by: 3

Documentation

Index

Constants

View Source 
const ENSABI = `` /* 1370-byte string literal not displayed */

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

View Source 
const ENSBin = `` /* 1614-byte string literal not displayed */

ENSBin is the compiled bytecode used for deploying new contracts.

View Source 
const FIFSRegistrarABI = `` /* 253-byte string literal not displayed */

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

View Source 
const FIFSRegistrarBin = `` /* 3138-byte string literal not displayed */

FIFSRegistrarBin is the compiled bytecode used for deploying new contracts.

View Source 
const PublicResolverABI = `` /* 1134-byte string literal not displayed */

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

View Source 
const PublicResolverBin = `` /* 1744-byte string literal not displayed */

PublicResolverBin is the compiled bytecode used for deploying new contracts.

View Source 
const ResolverABI = `` /* 773-byte string literal not displayed */

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

View Source 
const ResolverBin = `0x`

ResolverBin is the compiled bytecode used for deploying new contracts.

Variables

This section is empty.

Functions

This section is empty.

Types

type ENS 

type ENS struct {
	ENSCaller     // Read-only binding to the contract
	ENSTransactor // Write-only binding to the contract
}

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

func DeployENS 

func DeployENS(auth *bind.TransactOpts, backend bind.ContractBackend, owner common.Address) (common.Address, *types.Transaction, *ENS, error)

DeployENS deploys a new Ethereum contract, binding an instance of ENS to it.

func NewENS 

func NewENS(address common.Address, backend bind.ContractBackend) (*ENS, error)

NewENS creates a new instance of ENS, bound to a specific deployed contract.

type ENSCaller 

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

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

func NewENSCaller 

func NewENSCaller(address common.Address, caller bind.ContractCaller) (*ENSCaller, error)

NewENSCaller creates a new read-only instance of ENS, bound to a specific deployed contract.

func (*ENSCaller) Owner 

func (_ENS *ENSCaller) Owner(opts *bind.CallOpts, node [32]byte) (common.Address, error)

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

Solidity: function owner(node bytes32) constant returns(address)

func (*ENSCaller) Resolver 

func (_ENS *ENSCaller) Resolver(opts *bind.CallOpts, node [32]byte) (common.Address, error)

Resolver is a free data retrieval call binding the contract method 0x0178b8bf.

Solidity: function resolver(node bytes32) constant returns(address)

type ENSCallerRaw 

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

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

func (*ENSCallerRaw) Call 

func (_ENS *ENSCallerRaw) 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 ENSCallerSession 

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

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

func (*ENSCallerSession) Owner 

func (_ENS *ENSCallerSession) Owner(node [32]byte) (common.Address, error)

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

Solidity: function owner(node bytes32) constant returns(address)

func (*ENSCallerSession) Resolver 

func (_ENS *ENSCallerSession) Resolver(node [32]byte) (common.Address, error)

Resolver is a free data retrieval call binding the contract method 0x0178b8bf.

Solidity: function resolver(node bytes32) constant returns(address)

type ENSRaw 

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

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

func (*ENSRaw) Call 

func (_ENS *ENSRaw) 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 (*ENSRaw) Transact 

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

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

func (*ENSRaw) Transfer 

func (_ENS *ENSRaw) 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 ENSSession 

type ENSSession struct {
	Contract     *ENS              // 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
}

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

func (*ENSSession) Owner 

func (_ENS *ENSSession) Owner(node [32]byte) (common.Address, error)

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

Solidity: function owner(node bytes32) constant returns(address)

func (*ENSSession) Resolver 

func (_ENS *ENSSession) Resolver(node [32]byte) (common.Address, error)

Resolver is a free data retrieval call binding the contract method 0x0178b8bf.

Solidity: function resolver(node bytes32) constant returns(address)

func (*ENSSession) SetOwner 

func (_ENS *ENSSession) SetOwner(node [32]byte, owner common.Address) (*types.Transaction, error)

SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3.

Solidity: function setOwner(node bytes32, owner address) returns()

func (*ENSSession) SetResolver 

func (_ENS *ENSSession) SetResolver(node [32]byte, resolver common.Address) (*types.Transaction, error)

SetResolver is a paid mutator transaction binding the contract method 0x1896f70a.

Solidity: function setResolver(node bytes32, resolver address) returns()

func (*ENSSession) SetSubnodeOwner 

func (_ENS *ENSSession) SetSubnodeOwner(node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error)

SetSubnodeOwner is a paid mutator transaction binding the contract method 0x06ab5923.

Solidity: function setSubnodeOwner(node bytes32, label bytes32, owner address) returns()

type ENSTransactor 

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

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

func NewENSTransactor 

func NewENSTransactor(address common.Address, transactor bind.ContractTransactor) (*ENSTransactor, error)

NewENSTransactor creates a new write-only instance of ENS, bound to a specific deployed contract.

func (*ENSTransactor) SetOwner 

func (_ENS *ENSTransactor) SetOwner(opts *bind.TransactOpts, node [32]byte, owner common.Address) (*types.Transaction, error)

SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3.

Solidity: function setOwner(node bytes32, owner address) returns()

func (*ENSTransactor) SetResolver 

func (_ENS *ENSTransactor) SetResolver(opts *bind.TransactOpts, node [32]byte, resolver common.Address) (*types.Transaction, error)

SetResolver is a paid mutator transaction binding the contract method 0x1896f70a.

Solidity: function setResolver(node bytes32, resolver address) returns()

func (*ENSTransactor) SetSubnodeOwner 

func (_ENS *ENSTransactor) SetSubnodeOwner(opts *bind.TransactOpts, node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error)

SetSubnodeOwner is a paid mutator transaction binding the contract method 0x06ab5923.

Solidity: function setSubnodeOwner(node bytes32, label bytes32, owner address) returns()

type ENSTransactorRaw 

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

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

func (*ENSTransactorRaw) Transact 

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

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

func (*ENSTransactorRaw) Transfer 

func (_ENS *ENSTransactorRaw) 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 ENSTransactorSession 

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

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

func (*ENSTransactorSession) SetOwner 

func (_ENS *ENSTransactorSession) SetOwner(node [32]byte, owner common.Address) (*types.Transaction, error)

SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3.

Solidity: function setOwner(node bytes32, owner address) returns()

func (*ENSTransactorSession) SetResolver 

func (_ENS *ENSTransactorSession) SetResolver(node [32]byte, resolver common.Address) (*types.Transaction, error)

SetResolver is a paid mutator transaction binding the contract method 0x1896f70a.

Solidity: function setResolver(node bytes32, resolver address) returns()

func (*ENSTransactorSession) SetSubnodeOwner 

func (_ENS *ENSTransactorSession) SetSubnodeOwner(node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error)

SetSubnodeOwner is a paid mutator transaction binding the contract method 0x06ab5923.

Solidity: function setSubnodeOwner(node bytes32, label bytes32, owner address) returns()

type FIFSRegistrar 

type FIFSRegistrar struct {
	FIFSRegistrarCaller     // Read-only binding to the contract
	FIFSRegistrarTransactor // Write-only binding to the contract
}

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

func DeployFIFSRegistrar 

func DeployFIFSRegistrar(auth *bind.TransactOpts, backend bind.ContractBackend, ensAddr common.Address, node [32]byte) (common.Address, *types.Transaction, *FIFSRegistrar, error)

DeployFIFSRegistrar deploys a new Ethereum contract, binding an instance of FIFSRegistrar to it.

func NewFIFSRegistrar 

func NewFIFSRegistrar(address common.Address, backend bind.ContractBackend) (*FIFSRegistrar, error)

NewFIFSRegistrar creates a new instance of FIFSRegistrar, bound to a specific deployed contract.

type FIFSRegistrarCaller 

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

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

func NewFIFSRegistrarCaller 

func NewFIFSRegistrarCaller(address common.Address, caller bind.ContractCaller) (*FIFSRegistrarCaller, error)

NewFIFSRegistrarCaller creates a new read-only instance of FIFSRegistrar, bound to a specific deployed contract.

type FIFSRegistrarCallerRaw 

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

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

func (*FIFSRegistrarCallerRaw) Call 

func (_FIFSRegistrar *FIFSRegistrarCallerRaw) 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 FIFSRegistrarCallerSession 

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

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

type FIFSRegistrarRaw 

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

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

func (*FIFSRegistrarRaw) Call 

func (_FIFSRegistrar *FIFSRegistrarRaw) 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 (*FIFSRegistrarRaw) Transact 

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

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

func (*FIFSRegistrarRaw) Transfer 

func (_FIFSRegistrar *FIFSRegistrarRaw) 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 FIFSRegistrarSession 

type FIFSRegistrarSession struct {
	Contract     *FIFSRegistrar    // 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
}

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

func (*FIFSRegistrarSession) Register 

func (_FIFSRegistrar *FIFSRegistrarSession) Register(subnode [32]byte, owner common.Address) (*types.Transaction, error)

Register is a paid mutator transaction binding the contract method 0xd22057a9.

Solidity: function register(subnode bytes32, owner address) returns()

type FIFSRegistrarTransactor 

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

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

func NewFIFSRegistrarTransactor 

func NewFIFSRegistrarTransactor(address common.Address, transactor bind.ContractTransactor) (*FIFSRegistrarTransactor, error)

NewFIFSRegistrarTransactor creates a new write-only instance of FIFSRegistrar, bound to a specific deployed contract.

func (*FIFSRegistrarTransactor) Register 

func (_FIFSRegistrar *FIFSRegistrarTransactor) Register(opts *bind.TransactOpts, subnode [32]byte, owner common.Address) (*types.Transaction, error)

Register is a paid mutator transaction binding the contract method 0xd22057a9.

Solidity: function register(subnode bytes32, owner address) returns()

type FIFSRegistrarTransactorRaw 

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

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

func (*FIFSRegistrarTransactorRaw) Transact 

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

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

func (*FIFSRegistrarTransactorRaw) Transfer 

func (_FIFSRegistrar *FIFSRegistrarTransactorRaw) 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 FIFSRegistrarTransactorSession 

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

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

func (*FIFSRegistrarTransactorSession) Register 

func (_FIFSRegistrar *FIFSRegistrarTransactorSession) Register(subnode [32]byte, owner common.Address) (*types.Transaction, error)

Register is a paid mutator transaction binding the contract method 0xd22057a9.

Solidity: function register(subnode bytes32, owner address) returns()

type PublicResolver 

type PublicResolver struct {
	PublicResolverCaller     // Read-only binding to the contract
	PublicResolverTransactor // Write-only binding to the contract
}

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

func DeployPublicResolver 

func DeployPublicResolver(auth *bind.TransactOpts, backend bind.ContractBackend, ensAddr common.Address) (common.Address, *types.Transaction, *PublicResolver, error)

DeployPublicResolver deploys a new Ethereum contract, binding an instance of PublicResolver to it.

func NewPublicResolver 

func NewPublicResolver(address common.Address, backend bind.ContractBackend) (*PublicResolver, error)

NewPublicResolver creates a new instance of PublicResolver, bound to a specific deployed contract.

type PublicResolverCaller 

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

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

func NewPublicResolverCaller 

func NewPublicResolverCaller(address common.Address, caller bind.ContractCaller) (*PublicResolverCaller, error)

NewPublicResolverCaller creates a new read-only instance of PublicResolver, bound to a specific deployed contract.

func (*PublicResolverCaller) Addr 

func (_PublicResolver *PublicResolverCaller) Addr(opts *bind.CallOpts, node [32]byte) (common.Address, error)

Addr is a free data retrieval call binding the contract method 0x3b3b57de.

Solidity: function addr(node bytes32) constant returns(ret address)

func (*PublicResolverCaller) Content 

func (_PublicResolver *PublicResolverCaller) Content(opts *bind.CallOpts, node [32]byte) ([32]byte, error)

Content is a free data retrieval call binding the contract method 0x2dff6941.

Solidity: function content(node bytes32) constant returns(ret bytes32)

type PublicResolverCallerRaw 

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

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

func (*PublicResolverCallerRaw) Call 

func (_PublicResolver *PublicResolverCallerRaw) 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 PublicResolverCallerSession 

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

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

func (*PublicResolverCallerSession) Addr 

func (_PublicResolver *PublicResolverCallerSession) Addr(node [32]byte) (common.Address, error)

Addr is a free data retrieval call binding the contract method 0x3b3b57de.

Solidity: function addr(node bytes32) constant returns(ret address)

func (*PublicResolverCallerSession) Content 

func (_PublicResolver *PublicResolverCallerSession) Content(node [32]byte) ([32]byte, error)

Content is a free data retrieval call binding the contract method 0x2dff6941.

Solidity: function content(node bytes32) constant returns(ret bytes32)

type PublicResolverRaw 

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

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

func (*PublicResolverRaw) Call 

func (_PublicResolver *PublicResolverRaw) 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 (*PublicResolverRaw) Transact 

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

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

func (*PublicResolverRaw) Transfer 

func (_PublicResolver *PublicResolverRaw) 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 PublicResolverSession 

type PublicResolverSession struct {
	Contract     *PublicResolver   // 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
}

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

func (*PublicResolverSession) Addr 

func (_PublicResolver *PublicResolverSession) Addr(node [32]byte) (common.Address, error)

Addr is a free data retrieval call binding the contract method 0x3b3b57de.

Solidity: function addr(node bytes32) constant returns(ret address)

func (*PublicResolverSession) Content 

func (_PublicResolver *PublicResolverSession) Content(node [32]byte) ([32]byte, error)

Content is a free data retrieval call binding the contract method 0x2dff6941.

Solidity: function content(node bytes32) constant returns(ret bytes32)

func (*PublicResolverSession) Has 

func (_PublicResolver *PublicResolverSession) Has(node [32]byte, kind [32]byte) (*types.Transaction, error)

Has is a paid mutator transaction binding the contract method 0x41b9dc2b.

Solidity: function has(node bytes32, kind bytes32) returns(bool)

func (*PublicResolverSession) SetAddr 

func (_PublicResolver *PublicResolverSession) SetAddr(node [32]byte, addr common.Address) (*types.Transaction, error)

SetAddr is a paid mutator transaction binding the contract method 0xd5fa2b00.

Solidity: function setAddr(node bytes32, addr address) returns()

func (*PublicResolverSession) SetContent 

func (_PublicResolver *PublicResolverSession) SetContent(node [32]byte, hash [32]byte) (*types.Transaction, error)

SetContent is a paid mutator transaction binding the contract method 0xc3d014d6.

Solidity: function setContent(node bytes32, hash bytes32) returns()

type PublicResolverTransactor 

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

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

func NewPublicResolverTransactor 

func NewPublicResolverTransactor(address common.Address, transactor bind.ContractTransactor) (*PublicResolverTransactor, error)

NewPublicResolverTransactor creates a new write-only instance of PublicResolver, bound to a specific deployed contract.

func (*PublicResolverTransactor) Has 

func (_PublicResolver *PublicResolverTransactor) Has(opts *bind.TransactOpts, node [32]byte, kind [32]byte) (*types.Transaction, error)

Has is a paid mutator transaction binding the contract method 0x41b9dc2b.

Solidity: function has(node bytes32, kind bytes32) returns(bool)

func (*PublicResolverTransactor) SetAddr 

func (_PublicResolver *PublicResolverTransactor) SetAddr(opts *bind.TransactOpts, node [32]byte, addr common.Address) (*types.Transaction, error)

SetAddr is a paid mutator transaction binding the contract method 0xd5fa2b00.

Solidity: function setAddr(node bytes32, addr address) returns()

func (*PublicResolverTransactor) SetContent 

func (_PublicResolver *PublicResolverTransactor) SetContent(opts *bind.TransactOpts, node [32]byte, hash [32]byte) (*types.Transaction, error)

SetContent is a paid mutator transaction binding the contract method 0xc3d014d6.

Solidity: function setContent(node bytes32, hash bytes32) returns()

type PublicResolverTransactorRaw 

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

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

func (*PublicResolverTransactorRaw) Transact 

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

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

func (*PublicResolverTransactorRaw) Transfer 

func (_PublicResolver *PublicResolverTransactorRaw) 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 PublicResolverTransactorSession 

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

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

func (*PublicResolverTransactorSession) Has 

func (_PublicResolver *PublicResolverTransactorSession) Has(node [32]byte, kind [32]byte) (*types.Transaction, error)

Has is a paid mutator transaction binding the contract method 0x41b9dc2b.

Solidity: function has(node bytes32, kind bytes32) returns(bool)

func (*PublicResolverTransactorSession) SetAddr 

func (_PublicResolver *PublicResolverTransactorSession) SetAddr(node [32]byte, addr common.Address) (*types.Transaction, error)

SetAddr is a paid mutator transaction binding the contract method 0xd5fa2b00.

Solidity: function setAddr(node bytes32, addr address) returns()

func (*PublicResolverTransactorSession) SetContent 

func (_PublicResolver *PublicResolverTransactorSession) SetContent(node [32]byte, hash [32]byte) (*types.Transaction, error)

SetContent is a paid mutator transaction binding the contract method 0xc3d014d6.

Solidity: function setContent(node bytes32, hash bytes32) returns()

type Resolver 

type Resolver struct {
	ResolverCaller     // Read-only binding to the contract
	ResolverTransactor // Write-only binding to the contract
}

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

func DeployResolver 

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

DeployResolver deploys a new Ethereum contract, binding an instance of Resolver to it.

func NewResolver 

func NewResolver(address common.Address, backend bind.ContractBackend) (*Resolver, error)

NewResolver creates a new instance of Resolver, bound to a specific deployed contract.

type ResolverCaller 

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

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

func NewResolverCaller 

func NewResolverCaller(address common.Address, caller bind.ContractCaller) (*ResolverCaller, error)

NewResolverCaller creates a new read-only instance of Resolver, bound to a specific deployed contract.

func (*ResolverCaller) Addr 

func (_Resolver *ResolverCaller) Addr(opts *bind.CallOpts, node [32]byte) (common.Address, error)

Addr is a free data retrieval call binding the contract method 0x3b3b57de.

Solidity: function addr(node bytes32) constant returns(ret address)

func (*ResolverCaller) Content 

func (_Resolver *ResolverCaller) Content(opts *bind.CallOpts, node [32]byte) ([32]byte, error)

Content is a free data retrieval call binding the contract method 0x2dff6941.

Solidity: function content(node bytes32) constant returns(ret bytes32)

type ResolverCallerRaw 

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

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

func (*ResolverCallerRaw) Call 

func (_Resolver *ResolverCallerRaw) 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 ResolverCallerSession 

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

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

func (*ResolverCallerSession) Addr 

func (_Resolver *ResolverCallerSession) Addr(node [32]byte) (common.Address, error)

Addr is a free data retrieval call binding the contract method 0x3b3b57de.

Solidity: function addr(node bytes32) constant returns(ret address)

func (*ResolverCallerSession) Content 

func (_Resolver *ResolverCallerSession) Content(node [32]byte) ([32]byte, error)

Content is a free data retrieval call binding the contract method 0x2dff6941.

Solidity: function content(node bytes32) constant returns(ret bytes32)

type ResolverRaw 

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

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

func (*ResolverRaw) Call 

func (_Resolver *ResolverRaw) 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 (*ResolverRaw) Transact 

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

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

func (*ResolverRaw) Transfer 

func (_Resolver *ResolverRaw) 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 ResolverSession 

type ResolverSession struct {
	Contract     *Resolver         // 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
}

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

func (*ResolverSession) Addr 

func (_Resolver *ResolverSession) Addr(node [32]byte) (common.Address, error)

Addr is a free data retrieval call binding the contract method 0x3b3b57de.

Solidity: function addr(node bytes32) constant returns(ret address)

func (*ResolverSession) Content 

func (_Resolver *ResolverSession) Content(node [32]byte) ([32]byte, error)

Content is a free data retrieval call binding the contract method 0x2dff6941.

Solidity: function content(node bytes32) constant returns(ret bytes32)

func (*ResolverSession) Has 

func (_Resolver *ResolverSession) Has(node [32]byte, kind [32]byte) (*types.Transaction, error)

Has is a paid mutator transaction binding the contract method 0x41b9dc2b.

Solidity: function has(node bytes32, kind bytes32) returns(bool)

type ResolverTransactor 

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

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

func NewResolverTransactor 

func NewResolverTransactor(address common.Address, transactor bind.ContractTransactor) (*ResolverTransactor, error)

NewResolverTransactor creates a new write-only instance of Resolver, bound to a specific deployed contract.

func (*ResolverTransactor) Has 

func (_Resolver *ResolverTransactor) Has(opts *bind.TransactOpts, node [32]byte, kind [32]byte) (*types.Transaction, error)

Has is a paid mutator transaction binding the contract method 0x41b9dc2b.

Solidity: function has(node bytes32, kind bytes32) returns(bool)

type ResolverTransactorRaw 

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

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

func (*ResolverTransactorRaw) Transact 

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

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

func (*ResolverTransactorRaw) Transfer 

func (_Resolver *ResolverTransactorRaw) 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 ResolverTransactorSession 

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

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

func (*ResolverTransactorSession) Has 

func (_Resolver *ResolverTransactorSession) Has(node [32]byte, kind [32]byte) (*types.Transaction, error)

Has is a paid mutator transaction binding the contract method 0x41b9dc2b.

Solidity: function has(node bytes32, kind bytes32) returns(bool)

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.