verifier

package
v0.0.0-...-8af0f92 Latest Latest
Warning

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

Go to latest
Published: Jul 5, 2019 License: GPL-3.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 = `` /* 316-byte string literal not displayed */

PairingBin is the compiled bytecode used for deploying new contracts.

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

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

View Source
const VerifierBin = `` /* 8718-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) VerifyProof

func (_Verifier *VerifierCaller) VerifyProof(opts *bind.CallOpts, a [2]*big.Int, b [2][2]*big.Int, c [2]*big.Int, input [10]*big.Int) (bool, error)

VerifyProof is a free data retrieval call binding the contract method 0xf3bb70f6.

Solidity: function verifyProof(uint256[2] a, uint256[2][2] b, uint256[2] c, uint256[10] input) constant returns(bool r)

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) VerifyProof

func (_Verifier *VerifierCallerSession) VerifyProof(a [2]*big.Int, b [2][2]*big.Int, c [2]*big.Int, input [10]*big.Int) (bool, error)

VerifyProof is a free data retrieval call binding the contract method 0xf3bb70f6.

Solidity: function verifyProof(uint256[2] a, uint256[2][2] b, uint256[2] c, uint256[10] input) constant returns(bool r)

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.

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) VerifyProof

func (_Verifier *VerifierSession) VerifyProof(a [2]*big.Int, b [2][2]*big.Int, c [2]*big.Int, input [10]*big.Int) (bool, error)

VerifyProof is a free data retrieval call binding the contract method 0xf3bb70f6.

Solidity: function verifyProof(uint256[2] a, uint256[2][2] b, uint256[2] c, uint256[10] input) constant returns(bool r)

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.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL