circuit

package
v0.0.0-...-94c77a0 Latest Latest
Warning

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

 Go to latest Published: Aug 25, 2021 License: Apache-2.0 Imports: 11 Imported by: 0

Documentation

Index

Constants

View Source 
const PairingABI = "[]"

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

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

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

Variables

View Source 
var PairingBin = "" /* 284-byte string literal not displayed */

PairingBin is the compiled bytecode used for deploying new contracts.

View Source 
var VerifierBin = "" /* 8924-byte string literal not displayed */

VerifierBin is the compiled bytecode used for deploying new contracts.

View Source 
var VerifierFuncSigs = map[string]string{
	"43753b4d": "verifyProof(uint256[2],uint256[2][2],uint256[2],uint256[1])",
}

VerifierFuncSigs maps the 4-byte function signature to its string representation.

Functions

This section is empty.

Types

type Circuit 

type Circuit struct {
	Secret frontend.Variable
	Hash   frontend.Variable `gnark:",public"` // struct tags default visibility is "secret"
}

Circuit defines a pre-image knowledge proof mimc(secret preImage) = public hash

func (*Circuit) Define 

func (circuit *Circuit) Define(curveID ecc.ID, cs *frontend.ConstraintSystem) error

Define declares the circuit's constraints assert mimc(secret) == hash

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 [1]*big.Int) (bool, error)

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

Solidity: function verifyProof(uint256[2] a, uint256[2][2] b, uint256[2] c, uint256[1] input) view 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 [1]*big.Int) (bool, error)

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

Solidity: function verifyProof(uint256[2] a, uint256[2][2] b, uint256[2] c, uint256[1] input) view 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 [1]*big.Int) (bool, error)

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

Solidity: function verifyProof(uint256[2] a, uint256[2][2] b, uint256[2] c, uint256[1] input) view 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.

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.