verifier

package
v0.0.0-...-9fddba8 Latest Latest
Warning

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

 Go to latest Published: Jan 20, 2019 License: Apache-2.0 Imports: 8 Imported by: 0

Documentation

Index

Constants

View Source 
const PairingABI = "[]"

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

View Source 
const PairingBin = `` /* 242-byte string literal not displayed */

PairingBin is the compiled bytecode used for deploying new contracts.

View Source 
const VerifierABI = "" /* 686-byte string literal not displayed */

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

View Source 
const VerifierBin = `` /* 10280-byte string literal not displayed */

VerifierBin is the compiled bytecode used for deploying new contracts.

Variables

This section is empty.

Functions

This section is empty.

Types

type Pairing 

type Pairing struct {
	PairingCaller     // Read-only binding to the contract
	PairingTransactor // Write-only binding to the contract
	PairingFilterer   // Log filterer for contract events
}

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

func DeployPairing 

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

DeployPairing deploys a new Ethereum contract, binding an instance of Pairing to it.

func NewPairing 

func NewPairing(address common.Address, backend bind.ContractBackend) (*Pairing, error)

NewPairing creates a new instance of Pairing, bound to a specific deployed contract.

type PairingCaller 

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

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

func NewPairingCaller 

func NewPairingCaller(address common.Address, caller bind.ContractCaller) (*PairingCaller, error)

NewPairingCaller creates a new read-only instance of Pairing, bound to a specific deployed contract.

type PairingCallerRaw 

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

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

func (*PairingCallerRaw) Call 

func (_Pairing *PairingCallerRaw) 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 PairingCallerSession 

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

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

type PairingFilterer 

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

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

func NewPairingFilterer 

func NewPairingFilterer(address common.Address, filterer bind.ContractFilterer) (*PairingFilterer, error)

NewPairingFilterer creates a new log filterer instance of Pairing, bound to a specific deployed contract.

type PairingRaw 

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

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

func (*PairingRaw) Call 

func (_Pairing *PairingRaw) 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 (*PairingRaw) Transact 

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

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

func (*PairingRaw) Transfer 

func (_Pairing *PairingRaw) 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 PairingSession 

type PairingSession struct {
	Contract     *Pairing          // 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
}

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

type PairingTransactor 

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

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

func NewPairingTransactor 

func NewPairingTransactor(address common.Address, transactor bind.ContractTransactor) (*PairingTransactor, error)

NewPairingTransactor creates a new write-only instance of Pairing, bound to a specific deployed contract.

type PairingTransactorRaw 

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

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

func (*PairingTransactorRaw) Transact 

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

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

func (*PairingTransactorRaw) Transfer 

func (_Pairing *PairingTransactorRaw) 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 PairingTransactorSession 

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

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

type Verifier 

type Verifier struct {
	VerifierCaller     // Read-only binding to the contract
	VerifierTransactor // Write-only binding to the contract
	VerifierFilterer   // Log filterer for contract events
}

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

func DeployVerifier 

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

DeployVerifier deploys a new Ethereum contract, binding an instance of Verifier to it.

func NewVerifier 

func NewVerifier(address common.Address, backend bind.ContractBackend) (*Verifier, error)

NewVerifier creates a new instance of Verifier, bound to a specific deployed contract.

type VerifierCaller 

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

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

func NewVerifierCaller 

func NewVerifierCaller(address common.Address, caller bind.ContractCaller) (*VerifierCaller, error)

NewVerifierCaller creates a new read-only instance of Verifier, bound to a specific deployed contract.

func (*VerifierCaller) VerifyTx 

func (_Verifier *VerifierCaller) VerifyTx(opts *bind.CallOpts, a [2]*big.Int, a_p [2]*big.Int, b [2][2]*big.Int, b_p [2]*big.Int, c [2]*big.Int, c_p [2]*big.Int, h [2]*big.Int, k [2]*big.Int, input [3]*big.Int) (bool, error)

VerifyTx is a free data retrieval call binding the contract method 0xc834d03d.

Solidity: function verifyTx(a uint256[2], a_p uint256[2], b uint256[2][2], b_p uint256[2], c uint256[2], c_p uint256[2], h uint256[2], k uint256[2], input uint256[3]) constant returns(bool)

type VerifierCallerRaw 

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

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

func (*VerifierCallerRaw) Call 

func (_Verifier *VerifierCallerRaw) 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 VerifierCallerSession 

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

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

func (*VerifierCallerSession) VerifyTx 

func (_Verifier *VerifierCallerSession) VerifyTx(a [2]*big.Int, a_p [2]*big.Int, b [2][2]*big.Int, b_p [2]*big.Int, c [2]*big.Int, c_p [2]*big.Int, h [2]*big.Int, k [2]*big.Int, input [3]*big.Int) (bool, error)

VerifyTx is a free data retrieval call binding the contract method 0xc834d03d.

Solidity: function verifyTx(a uint256[2], a_p uint256[2], b uint256[2][2], b_p uint256[2], c uint256[2], c_p uint256[2], h uint256[2], k uint256[2], input uint256[3]) constant returns(bool)

type VerifierFilterer 

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

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

func NewVerifierFilterer 

func NewVerifierFilterer(address common.Address, filterer bind.ContractFilterer) (*VerifierFilterer, error)

NewVerifierFilterer creates a new log filterer instance of Verifier, bound to a specific deployed contract.

func (*VerifierFilterer) FilterVerified 

func (_Verifier *VerifierFilterer) FilterVerified(opts *bind.FilterOpts) (*VerifierVerifiedIterator, error)

FilterVerified is a free log retrieval operation binding the contract event 0x3f3cfdb26fb5f9f1786ab4f1a1f9cd4c0b5e726cbdfc26e495261731aad44e39.

Solidity: e Verified(s string)

func (*VerifierFilterer) WatchVerified 

func (_Verifier *VerifierFilterer) WatchVerified(opts *bind.WatchOpts, sink chan<- *VerifierVerified) (event.Subscription, error)

WatchVerified is a free log subscription operation binding the contract event 0x3f3cfdb26fb5f9f1786ab4f1a1f9cd4c0b5e726cbdfc26e495261731aad44e39.

Solidity: e Verified(s string)

type VerifierRaw 

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

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

func (*VerifierRaw) Call 

func (_Verifier *VerifierRaw) 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 (*VerifierRaw) Transact 

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

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

func (*VerifierRaw) Transfer 

func (_Verifier *VerifierRaw) 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 VerifierSession 

type VerifierSession struct {
	Contract     *Verifier         // 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
}

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

func (*VerifierSession) VerifyTx 

func (_Verifier *VerifierSession) VerifyTx(a [2]*big.Int, a_p [2]*big.Int, b [2][2]*big.Int, b_p [2]*big.Int, c [2]*big.Int, c_p [2]*big.Int, h [2]*big.Int, k [2]*big.Int, input [3]*big.Int) (bool, error)

VerifyTx is a free data retrieval call binding the contract method 0xc834d03d.

Solidity: function verifyTx(a uint256[2], a_p uint256[2], b uint256[2][2], b_p uint256[2], c uint256[2], c_p uint256[2], h uint256[2], k uint256[2], input uint256[3]) constant returns(bool)

type VerifierTransactor 

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

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

func NewVerifierTransactor 

func NewVerifierTransactor(address common.Address, transactor bind.ContractTransactor) (*VerifierTransactor, error)

NewVerifierTransactor creates a new write-only instance of Verifier, bound to a specific deployed contract.

type VerifierTransactorRaw 

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

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

func (*VerifierTransactorRaw) Transact 

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

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

func (*VerifierTransactorRaw) Transfer 

func (_Verifier *VerifierTransactorRaw) 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 VerifierTransactorSession 

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

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

type VerifierVerified 

type VerifierVerified struct {
	S   string
	Raw types.Log // Blockchain specific contextual infos
}

VerifierVerified represents a Verified event raised by the Verifier contract.

type VerifierVerifiedIterator 

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

VerifierVerifiedIterator is returned from FilterVerified and is used to iterate over the raw logs and unpacked data for Verified events raised by the Verifier contract.

func (*VerifierVerifiedIterator) Close 

func (it *VerifierVerifiedIterator) Close() error

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

func (*VerifierVerifiedIterator) Error 

func (it *VerifierVerifiedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*VerifierVerifiedIterator) Next 

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