checkfullcircuit

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 CheckFullCircuitABI = "" /* 1305-byte string literal not displayed */

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

View Source 
const CheckFullCircuitBin = `` /* 5098-byte string literal not displayed */

CheckFullCircuitBin is the compiled bytecode used for deploying new contracts.

View Source 
const Iden3HelpersABI = "" /* 624-byte string literal not displayed */

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

View Source 
const Iden3HelpersBin = `` /* 1302-byte string literal not displayed */

Iden3HelpersBin is the compiled bytecode used for deploying new contracts.

View Source 
const MemoryABI = "[]"

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

View Source 
const MemoryBin = `` /* 316-byte string literal not displayed */

MemoryBin is the compiled bytecode used for deploying new contracts.

View Source 
const MimcUnitABI = "" /* 249-byte string literal not displayed */

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

View Source 
const MimcUnitBin = `` /* 448-byte string literal not displayed */

MimcUnitBin is the compiled bytecode used for deploying new contracts.

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 RootCommitsABI = "" /* 1947-byte string literal not displayed */

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

View Source 
const RootCommitsBin = `` /* 9310-byte string literal not displayed */

RootCommitsBin 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.

View Source 
const WhitelistABI = "" /* 540-byte string literal not displayed */

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

View Source 
const WhitelistBin = `` /* 798-byte string literal not displayed */

WhitelistBin is the compiled bytecode used for deploying new contracts.

Variables

This section is empty.

Functions

This section is empty.

Types

type CheckFullCircuit 

type CheckFullCircuit struct {
	CheckFullCircuitCaller     // Read-only binding to the contract
	CheckFullCircuitTransactor // Write-only binding to the contract
	CheckFullCircuitFilterer   // Log filterer for contract events
}

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

func DeployCheckFullCircuit 

func DeployCheckFullCircuit(auth *bind.TransactOpts, backend bind.ContractBackend, smVerifier common.Address, smRoots common.Address, smWhitelist common.Address, _idCertifier [31]byte, _idStorer [31]byte) (common.Address, *types.Transaction, *CheckFullCircuit, error)

DeployCheckFullCircuit deploys a new Ethereum contract, binding an instance of CheckFullCircuit to it.

func NewCheckFullCircuit 

func NewCheckFullCircuit(address common.Address, backend bind.ContractBackend) (*CheckFullCircuit, error)

NewCheckFullCircuit creates a new instance of CheckFullCircuit, bound to a specific deployed contract.

type CheckFullCircuitCaller 

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

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

func NewCheckFullCircuitCaller 

func NewCheckFullCircuitCaller(address common.Address, caller bind.ContractCaller) (*CheckFullCircuitCaller, error)

NewCheckFullCircuitCaller creates a new read-only instance of CheckFullCircuit, bound to a specific deployed contract.

func (*CheckFullCircuitCaller) InputsKYC 

func (_CheckFullCircuit *CheckFullCircuitCaller) InputsKYC(opts *bind.CallOpts, arg0 common.Address) (struct {
	UserEncPubKeyX *big.Int
	UserEncPubKeyY *big.Int
	EncUuidX       *big.Int
}, error)

InputsKYC is a free data retrieval call binding the contract method 0x9698a172.

Solidity: function inputsKYC(address ) constant returns(uint256 userEncPubKeyX, uint256 userEncPubKeyY, uint256 encUuidX)

type CheckFullCircuitCallerRaw 

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

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

func (*CheckFullCircuitCallerRaw) Call 

func (_CheckFullCircuit *CheckFullCircuitCallerRaw) 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 CheckFullCircuitCallerSession 

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

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

func (*CheckFullCircuitCallerSession) InputsKYC 

func (_CheckFullCircuit *CheckFullCircuitCallerSession) InputsKYC(arg0 common.Address) (struct {
	UserEncPubKeyX *big.Int
	UserEncPubKeyY *big.Int
	EncUuidX       *big.Int
}, error)

InputsKYC is a free data retrieval call binding the contract method 0x9698a172.

Solidity: function inputsKYC(address ) constant returns(uint256 userEncPubKeyX, uint256 userEncPubKeyY, uint256 encUuidX)

type CheckFullCircuitFilterer 

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

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

func NewCheckFullCircuitFilterer 

func NewCheckFullCircuitFilterer(address common.Address, filterer bind.ContractFilterer) (*CheckFullCircuitFilterer, error)

NewCheckFullCircuitFilterer creates a new log filterer instance of CheckFullCircuit, bound to a specific deployed contract.

func (*CheckFullCircuitFilterer) FilterRegisterId 

func (_CheckFullCircuit *CheckFullCircuitFilterer) FilterRegisterId(opts *bind.FilterOpts) (*CheckFullCircuitRegisterIdIterator, error)

FilterRegisterId is a free log retrieval operation binding the contract event 0x4b762c5f9176ec51200505065b864bb94492e8957a741f45e31b832875395f99.

Solidity: event registerId(address addr, uint256 userEncPubKeyX, uint256 userEncPubKeyY, uint256 encUuidX)

func (*CheckFullCircuitFilterer) WatchRegisterId 

func (_CheckFullCircuit *CheckFullCircuitFilterer) WatchRegisterId(opts *bind.WatchOpts, sink chan<- *CheckFullCircuitRegisterId) (event.Subscription, error)

WatchRegisterId is a free log subscription operation binding the contract event 0x4b762c5f9176ec51200505065b864bb94492e8957a741f45e31b832875395f99.

Solidity: event registerId(address addr, uint256 userEncPubKeyX, uint256 userEncPubKeyY, uint256 encUuidX)

type CheckFullCircuitRaw 

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

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

func (*CheckFullCircuitRaw) Call 

func (_CheckFullCircuit *CheckFullCircuitRaw) 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 (*CheckFullCircuitRaw) Transact 

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

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

func (*CheckFullCircuitRaw) Transfer 

func (_CheckFullCircuit *CheckFullCircuitRaw) 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 CheckFullCircuitRegisterId 

type CheckFullCircuitRegisterId struct {
	Addr           common.Address
	UserEncPubKeyX *big.Int
	UserEncPubKeyY *big.Int
	EncUuidX       *big.Int
	Raw            types.Log // Blockchain specific contextual infos
}

CheckFullCircuitRegisterId represents a RegisterId event raised by the CheckFullCircuit contract.

type CheckFullCircuitRegisterIdIterator 

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

CheckFullCircuitRegisterIdIterator is returned from FilterRegisterId and is used to iterate over the raw logs and unpacked data for RegisterId events raised by the CheckFullCircuit contract.

func (*CheckFullCircuitRegisterIdIterator) Close 

func (it *CheckFullCircuitRegisterIdIterator) Close() error

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

func (*CheckFullCircuitRegisterIdIterator) Error 

func (it *CheckFullCircuitRegisterIdIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*CheckFullCircuitRegisterIdIterator) Next 

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

type CheckFullCircuitSession 

type CheckFullCircuitSession struct {
	Contract     *CheckFullCircuit // 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
}

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

func (*CheckFullCircuitSession) InputsKYC 

func (_CheckFullCircuit *CheckFullCircuitSession) InputsKYC(arg0 common.Address) (struct {
	UserEncPubKeyX *big.Int
	UserEncPubKeyY *big.Int
	EncUuidX       *big.Int
}, error)

InputsKYC is a free data retrieval call binding the contract method 0x9698a172.

Solidity: function inputsKYC(address ) constant returns(uint256 userEncPubKeyX, uint256 userEncPubKeyY, uint256 encUuidX)

func (*CheckFullCircuitSession) Verify 

func (_CheckFullCircuit *CheckFullCircuitSession) Verify(a [2]*big.Int, b [2][2]*big.Int, c [2]*big.Int, input [10]*big.Int) (*types.Transaction, error)

Verify is a paid mutator transaction binding the contract method 0x636db9a7.

Solidity: function verify(uint256[2] a, uint256[2][2] b, uint256[2] c, uint256[10] input) returns()

type CheckFullCircuitTransactor 

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

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

func NewCheckFullCircuitTransactor 

func NewCheckFullCircuitTransactor(address common.Address, transactor bind.ContractTransactor) (*CheckFullCircuitTransactor, error)

NewCheckFullCircuitTransactor creates a new write-only instance of CheckFullCircuit, bound to a specific deployed contract.

func (*CheckFullCircuitTransactor) Verify 

func (_CheckFullCircuit *CheckFullCircuitTransactor) Verify(opts *bind.TransactOpts, a [2]*big.Int, b [2][2]*big.Int, c [2]*big.Int, input [10]*big.Int) (*types.Transaction, error)

Verify is a paid mutator transaction binding the contract method 0x636db9a7.

Solidity: function verify(uint256[2] a, uint256[2][2] b, uint256[2] c, uint256[10] input) returns()

type CheckFullCircuitTransactorRaw 

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

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

func (*CheckFullCircuitTransactorRaw) Transact 

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

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

func (*CheckFullCircuitTransactorRaw) Transfer 

func (_CheckFullCircuit *CheckFullCircuitTransactorRaw) 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 CheckFullCircuitTransactorSession 

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

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

func (*CheckFullCircuitTransactorSession) Verify 

func (_CheckFullCircuit *CheckFullCircuitTransactorSession) Verify(a [2]*big.Int, b [2][2]*big.Int, c [2]*big.Int, input [10]*big.Int) (*types.Transaction, error)

Verify is a paid mutator transaction binding the contract method 0x636db9a7.

Solidity: function verify(uint256[2] a, uint256[2][2] b, uint256[2] c, uint256[10] input) returns()

type Iden3Helpers 

type Iden3Helpers struct {
	Iden3HelpersCaller     // Read-only binding to the contract
	Iden3HelpersTransactor // Write-only binding to the contract
	Iden3HelpersFilterer   // Log filterer for contract events
}

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

func DeployIden3Helpers 

func DeployIden3Helpers(auth *bind.TransactOpts, backend bind.ContractBackend, _mimcContractAddr common.Address) (common.Address, *types.Transaction, *Iden3Helpers, error)

DeployIden3Helpers deploys a new Ethereum contract, binding an instance of Iden3Helpers to it.

func NewIden3Helpers 

func NewIden3Helpers(address common.Address, backend bind.ContractBackend) (*Iden3Helpers, error)

NewIden3Helpers creates a new instance of Iden3Helpers, bound to a specific deployed contract.

type Iden3HelpersCaller 

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

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

func NewIden3HelpersCaller 

func NewIden3HelpersCaller(address common.Address, caller bind.ContractCaller) (*Iden3HelpersCaller, error)

NewIden3HelpersCaller creates a new read-only instance of Iden3Helpers, bound to a specific deployed contract.

func (*Iden3HelpersCaller) CheckSig 

func (_Iden3Helpers *Iden3HelpersCaller) CheckSig(opts *bind.CallOpts, msgHash [32]byte, rsv []byte) (common.Address, error)

CheckSig is a free data retrieval call binding the contract method 0x01b0452c.

Solidity: function checkSig(bytes32 msgHash, bytes rsv) constant returns(address)

func (*Iden3HelpersCaller) GetRootFromId 

func (_Iden3Helpers *Iden3HelpersCaller) GetRootFromId(opts *bind.CallOpts, id [31]byte) ([27]byte, error)

GetRootFromId is a free data retrieval call binding the contract method 0xad05a8d2.

Solidity: function getRootFromId(bytes31 id) constant returns(bytes27)

type Iden3HelpersCallerRaw 

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

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

func (*Iden3HelpersCallerRaw) Call 

func (_Iden3Helpers *Iden3HelpersCallerRaw) 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 Iden3HelpersCallerSession 

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

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

func (*Iden3HelpersCallerSession) CheckSig 

func (_Iden3Helpers *Iden3HelpersCallerSession) CheckSig(msgHash [32]byte, rsv []byte) (common.Address, error)

CheckSig is a free data retrieval call binding the contract method 0x01b0452c.

Solidity: function checkSig(bytes32 msgHash, bytes rsv) constant returns(address)

func (*Iden3HelpersCallerSession) GetRootFromId 

func (_Iden3Helpers *Iden3HelpersCallerSession) GetRootFromId(id [31]byte) ([27]byte, error)

GetRootFromId is a free data retrieval call binding the contract method 0xad05a8d2.

Solidity: function getRootFromId(bytes31 id) constant returns(bytes27)

type Iden3HelpersFilterer 

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

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

func NewIden3HelpersFilterer 

func NewIden3HelpersFilterer(address common.Address, filterer bind.ContractFilterer) (*Iden3HelpersFilterer, error)

NewIden3HelpersFilterer creates a new log filterer instance of Iden3Helpers, bound to a specific deployed contract.

type Iden3HelpersRaw 

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

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

func (*Iden3HelpersRaw) Call 

func (_Iden3Helpers *Iden3HelpersRaw) 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 (*Iden3HelpersRaw) Transact 

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

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

func (*Iden3HelpersRaw) Transfer 

func (_Iden3Helpers *Iden3HelpersRaw) 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 Iden3HelpersSession 

type Iden3HelpersSession struct {
	Contract     *Iden3Helpers     // 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
}

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

func (*Iden3HelpersSession) CheckSig 

func (_Iden3Helpers *Iden3HelpersSession) CheckSig(msgHash [32]byte, rsv []byte) (common.Address, error)

CheckSig is a free data retrieval call binding the contract method 0x01b0452c.

Solidity: function checkSig(bytes32 msgHash, bytes rsv) constant returns(address)

func (*Iden3HelpersSession) GetRootFromId 

func (_Iden3Helpers *Iden3HelpersSession) GetRootFromId(id [31]byte) ([27]byte, error)

GetRootFromId is a free data retrieval call binding the contract method 0xad05a8d2.

Solidity: function getRootFromId(bytes31 id) constant returns(bytes27)

type Iden3HelpersTransactor 

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

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

func NewIden3HelpersTransactor 

func NewIden3HelpersTransactor(address common.Address, transactor bind.ContractTransactor) (*Iden3HelpersTransactor, error)

NewIden3HelpersTransactor creates a new write-only instance of Iden3Helpers, bound to a specific deployed contract.

type Iden3HelpersTransactorRaw 

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

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

func (*Iden3HelpersTransactorRaw) Transact 

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

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

func (*Iden3HelpersTransactorRaw) Transfer 

func (_Iden3Helpers *Iden3HelpersTransactorRaw) 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 Iden3HelpersTransactorSession 

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

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

type Memory 

type Memory struct {
	MemoryCaller     // Read-only binding to the contract
	MemoryTransactor // Write-only binding to the contract
	MemoryFilterer   // Log filterer for contract events
}

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

func DeployMemory 

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

DeployMemory deploys a new Ethereum contract, binding an instance of Memory to it.

func NewMemory 

func NewMemory(address common.Address, backend bind.ContractBackend) (*Memory, error)

NewMemory creates a new instance of Memory, bound to a specific deployed contract.

type MemoryCaller 

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

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

func NewMemoryCaller 

func NewMemoryCaller(address common.Address, caller bind.ContractCaller) (*MemoryCaller, error)

NewMemoryCaller creates a new read-only instance of Memory, bound to a specific deployed contract.

type MemoryCallerRaw 

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

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

func (*MemoryCallerRaw) Call 

func (_Memory *MemoryCallerRaw) 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 MemoryCallerSession 

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

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

type MemoryFilterer 

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

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

func NewMemoryFilterer 

func NewMemoryFilterer(address common.Address, filterer bind.ContractFilterer) (*MemoryFilterer, error)

NewMemoryFilterer creates a new log filterer instance of Memory, bound to a specific deployed contract.

type MemoryRaw 

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

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

func (*MemoryRaw) Call 

func (_Memory *MemoryRaw) 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 (*MemoryRaw) Transact 

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

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

func (*MemoryRaw) Transfer 

func (_Memory *MemoryRaw) 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 MemorySession 

type MemorySession struct {
	Contract     *Memory           // 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
}

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

type MemoryTransactor 

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

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

func NewMemoryTransactor 

func NewMemoryTransactor(address common.Address, transactor bind.ContractTransactor) (*MemoryTransactor, error)

NewMemoryTransactor creates a new write-only instance of Memory, bound to a specific deployed contract.

type MemoryTransactorRaw 

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

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

func (*MemoryTransactorRaw) Transact 

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

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

func (*MemoryTransactorRaw) Transfer 

func (_Memory *MemoryTransactorRaw) 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 MemoryTransactorSession 

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

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

type MimcUnit 

type MimcUnit struct {
	MimcUnitCaller     // Read-only binding to the contract
	MimcUnitTransactor // Write-only binding to the contract
	MimcUnitFilterer   // Log filterer for contract events
}

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

func DeployMimcUnit 

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

DeployMimcUnit deploys a new Ethereum contract, binding an instance of MimcUnit to it.

func NewMimcUnit 

func NewMimcUnit(address common.Address, backend bind.ContractBackend) (*MimcUnit, error)

NewMimcUnit creates a new instance of MimcUnit, bound to a specific deployed contract.

type MimcUnitCaller 

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

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

func NewMimcUnitCaller 

func NewMimcUnitCaller(address common.Address, caller bind.ContractCaller) (*MimcUnitCaller, error)

NewMimcUnitCaller creates a new read-only instance of MimcUnit, bound to a specific deployed contract.

func (*MimcUnitCaller) MiMCpe7 

func (_MimcUnit *MimcUnitCaller) MiMCpe7(opts *bind.CallOpts, arg0 *big.Int, arg1 *big.Int) (*big.Int, error)

MiMCpe7 is a free data retrieval call binding the contract method 0xd15ca109.

Solidity: function MiMCpe7(uint256 , uint256 ) constant returns(uint256)

type MimcUnitCallerRaw 

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

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

func (*MimcUnitCallerRaw) Call 

func (_MimcUnit *MimcUnitCallerRaw) 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 MimcUnitCallerSession 

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

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

func (*MimcUnitCallerSession) MiMCpe7 

func (_MimcUnit *MimcUnitCallerSession) MiMCpe7(arg0 *big.Int, arg1 *big.Int) (*big.Int, error)

MiMCpe7 is a free data retrieval call binding the contract method 0xd15ca109.

Solidity: function MiMCpe7(uint256 , uint256 ) constant returns(uint256)

type MimcUnitFilterer 

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

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

func NewMimcUnitFilterer 

func NewMimcUnitFilterer(address common.Address, filterer bind.ContractFilterer) (*MimcUnitFilterer, error)

NewMimcUnitFilterer creates a new log filterer instance of MimcUnit, bound to a specific deployed contract.

type MimcUnitRaw 

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

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

func (*MimcUnitRaw) Call 

func (_MimcUnit *MimcUnitRaw) 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 (*MimcUnitRaw) Transact 

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

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

func (*MimcUnitRaw) Transfer 

func (_MimcUnit *MimcUnitRaw) 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 MimcUnitSession 

type MimcUnitSession struct {
	Contract     *MimcUnit         // 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
}

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

func (*MimcUnitSession) MiMCpe7 

func (_MimcUnit *MimcUnitSession) MiMCpe7(arg0 *big.Int, arg1 *big.Int) (*big.Int, error)

MiMCpe7 is a free data retrieval call binding the contract method 0xd15ca109.

Solidity: function MiMCpe7(uint256 , uint256 ) constant returns(uint256)

type MimcUnitTransactor 

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

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

func NewMimcUnitTransactor 

func NewMimcUnitTransactor(address common.Address, transactor bind.ContractTransactor) (*MimcUnitTransactor, error)

NewMimcUnitTransactor creates a new write-only instance of MimcUnit, bound to a specific deployed contract.

type MimcUnitTransactorRaw 

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

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

func (*MimcUnitTransactorRaw) Transact 

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

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

func (*MimcUnitTransactorRaw) Transfer 

func (_MimcUnit *MimcUnitTransactorRaw) 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 MimcUnitTransactorSession 

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

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

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 RootCommits 

type RootCommits struct {
	RootCommitsCaller     // Read-only binding to the contract
	RootCommitsTransactor // Write-only binding to the contract
	RootCommitsFilterer   // Log filterer for contract events
}

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

func DeployRootCommits 

func DeployRootCommits(auth *bind.TransactOpts, backend bind.ContractBackend, _mimcContractAddr common.Address) (common.Address, *types.Transaction, *RootCommits, error)

DeployRootCommits deploys a new Ethereum contract, binding an instance of RootCommits to it.

func NewRootCommits 

func NewRootCommits(address common.Address, backend bind.ContractBackend) (*RootCommits, error)

NewRootCommits creates a new instance of RootCommits, bound to a specific deployed contract.

type RootCommitsCaller 

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

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

func NewRootCommitsCaller 

func NewRootCommitsCaller(address common.Address, caller bind.ContractCaller) (*RootCommitsCaller, error)

NewRootCommitsCaller creates a new read-only instance of RootCommits, bound to a specific deployed contract.

func (*RootCommitsCaller) CheckSig 

func (_RootCommits *RootCommitsCaller) CheckSig(opts *bind.CallOpts, msgHash [32]byte, rsv []byte) (common.Address, error)

CheckSig is a free data retrieval call binding the contract method 0x01b0452c.

Solidity: function checkSig(bytes32 msgHash, bytes rsv) constant returns(address)

func (*RootCommitsCaller) GetRoot 

func (_RootCommits *RootCommitsCaller) GetRoot(opts *bind.CallOpts, id [31]byte) ([32]byte, error)

GetRoot is a free data retrieval call binding the contract method 0xfead90d7.

Solidity: function getRoot(bytes31 id) constant returns(bytes32)

func (*RootCommitsCaller) GetRootByBlock 

func (_RootCommits *RootCommitsCaller) GetRootByBlock(opts *bind.CallOpts, id [31]byte, blockN uint64) ([32]byte, error)

GetRootByBlock is a free data retrieval call binding the contract method 0xb816ff6f.

Solidity: function getRootByBlock(bytes31 id, uint64 blockN) constant returns(bytes32)

func (*RootCommitsCaller) GetRootByTime 

func (_RootCommits *RootCommitsCaller) GetRootByTime(opts *bind.CallOpts, id [31]byte, timestamp uint64) ([32]byte, error)

GetRootByTime is a free data retrieval call binding the contract method 0x4175dae5.

Solidity: function getRootByTime(bytes31 id, uint64 timestamp) constant returns(bytes32)

func (*RootCommitsCaller) GetRootFromId 

func (_RootCommits *RootCommitsCaller) GetRootFromId(opts *bind.CallOpts, id [31]byte) ([27]byte, error)

GetRootFromId is a free data retrieval call binding the contract method 0xad05a8d2.

Solidity: function getRootFromId(bytes31 id) constant returns(bytes27)

type RootCommitsCallerRaw 

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

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

func (*RootCommitsCallerRaw) Call 

func (_RootCommits *RootCommitsCallerRaw) 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 RootCommitsCallerSession 

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

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

func (*RootCommitsCallerSession) CheckSig 

func (_RootCommits *RootCommitsCallerSession) CheckSig(msgHash [32]byte, rsv []byte) (common.Address, error)

CheckSig is a free data retrieval call binding the contract method 0x01b0452c.

Solidity: function checkSig(bytes32 msgHash, bytes rsv) constant returns(address)

func (*RootCommitsCallerSession) GetRoot 

func (_RootCommits *RootCommitsCallerSession) GetRoot(id [31]byte) ([32]byte, error)

GetRoot is a free data retrieval call binding the contract method 0xfead90d7.

Solidity: function getRoot(bytes31 id) constant returns(bytes32)

func (*RootCommitsCallerSession) GetRootByBlock 

func (_RootCommits *RootCommitsCallerSession) GetRootByBlock(id [31]byte, blockN uint64) ([32]byte, error)

GetRootByBlock is a free data retrieval call binding the contract method 0xb816ff6f.

Solidity: function getRootByBlock(bytes31 id, uint64 blockN) constant returns(bytes32)

func (*RootCommitsCallerSession) GetRootByTime 

func (_RootCommits *RootCommitsCallerSession) GetRootByTime(id [31]byte, timestamp uint64) ([32]byte, error)

GetRootByTime is a free data retrieval call binding the contract method 0x4175dae5.

Solidity: function getRootByTime(bytes31 id, uint64 timestamp) constant returns(bytes32)

func (*RootCommitsCallerSession) GetRootFromId 

func (_RootCommits *RootCommitsCallerSession) GetRootFromId(id [31]byte) ([27]byte, error)

GetRootFromId is a free data retrieval call binding the contract method 0xad05a8d2.

Solidity: function getRootFromId(bytes31 id) constant returns(bytes27)

type RootCommitsFilterer 

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

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

func NewRootCommitsFilterer 

func NewRootCommitsFilterer(address common.Address, filterer bind.ContractFilterer) (*RootCommitsFilterer, error)

NewRootCommitsFilterer creates a new log filterer instance of RootCommits, bound to a specific deployed contract.

func (*RootCommitsFilterer) FilterRootUpdated 

func (_RootCommits *RootCommitsFilterer) FilterRootUpdated(opts *bind.FilterOpts) (*RootCommitsRootUpdatedIterator, error)

FilterRootUpdated is a free log retrieval operation binding the contract event 0xc26526f78af19d7325e758deea00a04b0db26e055a576222266dfe241755a57f.

Solidity: event RootUpdated(bytes31 id, uint64 blockN, uint64 timestamp, bytes32 root)

func (*RootCommitsFilterer) WatchRootUpdated 

func (_RootCommits *RootCommitsFilterer) WatchRootUpdated(opts *bind.WatchOpts, sink chan<- *RootCommitsRootUpdated) (event.Subscription, error)

WatchRootUpdated is a free log subscription operation binding the contract event 0xc26526f78af19d7325e758deea00a04b0db26e055a576222266dfe241755a57f.

Solidity: event RootUpdated(bytes31 id, uint64 blockN, uint64 timestamp, bytes32 root)

type RootCommitsRaw 

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

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

func (*RootCommitsRaw) Call 

func (_RootCommits *RootCommitsRaw) 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 (*RootCommitsRaw) Transact 

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

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

func (*RootCommitsRaw) Transfer 

func (_RootCommits *RootCommitsRaw) 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 RootCommitsRootUpdated 

type RootCommitsRootUpdated struct {
	Id        [31]byte
	BlockN    uint64
	Timestamp uint64
	Root      [32]byte
	Raw       types.Log // Blockchain specific contextual infos
}

RootCommitsRootUpdated represents a RootUpdated event raised by the RootCommits contract.

type RootCommitsRootUpdatedIterator 

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

RootCommitsRootUpdatedIterator is returned from FilterRootUpdated and is used to iterate over the raw logs and unpacked data for RootUpdated events raised by the RootCommits contract.

func (*RootCommitsRootUpdatedIterator) Close 

func (it *RootCommitsRootUpdatedIterator) Close() error

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

func (*RootCommitsRootUpdatedIterator) Error 

func (it *RootCommitsRootUpdatedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*RootCommitsRootUpdatedIterator) Next 

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

type RootCommitsSession 

type RootCommitsSession struct {
	Contract     *RootCommits      // 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
}

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

func (*RootCommitsSession) CheckSig 

func (_RootCommits *RootCommitsSession) CheckSig(msgHash [32]byte, rsv []byte) (common.Address, error)

CheckSig is a free data retrieval call binding the contract method 0x01b0452c.

Solidity: function checkSig(bytes32 msgHash, bytes rsv) constant returns(address)

func (*RootCommitsSession) GetRoot 

func (_RootCommits *RootCommitsSession) GetRoot(id [31]byte) ([32]byte, error)

GetRoot is a free data retrieval call binding the contract method 0xfead90d7.

Solidity: function getRoot(bytes31 id) constant returns(bytes32)

func (*RootCommitsSession) GetRootByBlock 

func (_RootCommits *RootCommitsSession) GetRootByBlock(id [31]byte, blockN uint64) ([32]byte, error)

GetRootByBlock is a free data retrieval call binding the contract method 0xb816ff6f.

Solidity: function getRootByBlock(bytes31 id, uint64 blockN) constant returns(bytes32)

func (*RootCommitsSession) GetRootByTime 

func (_RootCommits *RootCommitsSession) GetRootByTime(id [31]byte, timestamp uint64) ([32]byte, error)

GetRootByTime is a free data retrieval call binding the contract method 0x4175dae5.

Solidity: function getRootByTime(bytes31 id, uint64 timestamp) constant returns(bytes32)

func (*RootCommitsSession) GetRootFromId 

func (_RootCommits *RootCommitsSession) GetRootFromId(id [31]byte) ([27]byte, error)

GetRootFromId is a free data retrieval call binding the contract method 0xad05a8d2.

Solidity: function getRootFromId(bytes31 id) constant returns(bytes27)

func (*RootCommitsSession) SetRoot 

func (_RootCommits *RootCommitsSession) SetRoot(newRoot [32]byte, id [31]byte, mtp []byte) (*types.Transaction, error)

SetRoot is a paid mutator transaction binding the contract method 0xe0681acd.

Solidity: function setRoot(bytes32 newRoot, bytes31 id, bytes mtp) returns()

type RootCommitsTransactor 

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

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

func NewRootCommitsTransactor 

func NewRootCommitsTransactor(address common.Address, transactor bind.ContractTransactor) (*RootCommitsTransactor, error)

NewRootCommitsTransactor creates a new write-only instance of RootCommits, bound to a specific deployed contract.

func (*RootCommitsTransactor) SetRoot 

func (_RootCommits *RootCommitsTransactor) SetRoot(opts *bind.TransactOpts, newRoot [32]byte, id [31]byte, mtp []byte) (*types.Transaction, error)

SetRoot is a paid mutator transaction binding the contract method 0xe0681acd.

Solidity: function setRoot(bytes32 newRoot, bytes31 id, bytes mtp) returns()

type RootCommitsTransactorRaw 

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

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

func (*RootCommitsTransactorRaw) Transact 

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

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

func (*RootCommitsTransactorRaw) Transfer 

func (_RootCommits *RootCommitsTransactorRaw) 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 RootCommitsTransactorSession 

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

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

func (*RootCommitsTransactorSession) SetRoot 

func (_RootCommits *RootCommitsTransactorSession) SetRoot(newRoot [32]byte, id [31]byte, mtp []byte) (*types.Transaction, error)

SetRoot is a paid mutator transaction binding the contract method 0xe0681acd.

Solidity: function setRoot(bytes32 newRoot, bytes31 id, bytes mtp) returns()

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.

type Whitelist 

type Whitelist struct {
	WhitelistCaller     // Read-only binding to the contract
	WhitelistTransactor // Write-only binding to the contract
	WhitelistFilterer   // Log filterer for contract events
}

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

func DeployWhitelist 

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

DeployWhitelist deploys a new Ethereum contract, binding an instance of Whitelist to it.

func NewWhitelist 

func NewWhitelist(address common.Address, backend bind.ContractBackend) (*Whitelist, error)

NewWhitelist creates a new instance of Whitelist, bound to a specific deployed contract.

type WhitelistCaller 

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

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

func NewWhitelistCaller 

func NewWhitelistCaller(address common.Address, caller bind.ContractCaller) (*WhitelistCaller, error)

NewWhitelistCaller creates a new read-only instance of Whitelist, bound to a specific deployed contract.

func (*WhitelistCaller) IsRegistered 

func (_Whitelist *WhitelistCaller) IsRegistered(opts *bind.CallOpts, addr common.Address) (bool, error)

IsRegistered is a free data retrieval call binding the contract method 0xc3c5a547.

Solidity: function isRegistered(address addr) constant returns(bool)

type WhitelistCallerRaw 

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

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

func (*WhitelistCallerRaw) Call 

func (_Whitelist *WhitelistCallerRaw) 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 WhitelistCallerSession 

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

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

func (*WhitelistCallerSession) IsRegistered 

func (_Whitelist *WhitelistCallerSession) IsRegistered(addr common.Address) (bool, error)

IsRegistered is a free data retrieval call binding the contract method 0xc3c5a547.

Solidity: function isRegistered(address addr) constant returns(bool)

type WhitelistFilterer 

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

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

func NewWhitelistFilterer 

func NewWhitelistFilterer(address common.Address, filterer bind.ContractFilterer) (*WhitelistFilterer, error)

NewWhitelistFilterer creates a new log filterer instance of Whitelist, bound to a specific deployed contract.

func (*WhitelistFilterer) FilterRegister 

func (_Whitelist *WhitelistFilterer) FilterRegister(opts *bind.FilterOpts) (*WhitelistRegisterIterator, error)

FilterRegister is a free log retrieval operation binding the contract event 0xeeda149c76076b34d4b9d8896c2f7efc0d33d1c7b53ea3c5db490d64613f603a.

Solidity: event Register(address addr)

func (*WhitelistFilterer) WatchRegister 

func (_Whitelist *WhitelistFilterer) WatchRegister(opts *bind.WatchOpts, sink chan<- *WhitelistRegister) (event.Subscription, error)

WatchRegister is a free log subscription operation binding the contract event 0xeeda149c76076b34d4b9d8896c2f7efc0d33d1c7b53ea3c5db490d64613f603a.

Solidity: event Register(address addr)

type WhitelistRaw 

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

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

func (*WhitelistRaw) Call 

func (_Whitelist *WhitelistRaw) 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 (*WhitelistRaw) Transact 

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

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

func (*WhitelistRaw) Transfer 

func (_Whitelist *WhitelistRaw) 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 WhitelistRegister 

type WhitelistRegister struct {
	Addr common.Address
	Raw  types.Log // Blockchain specific contextual infos
}

WhitelistRegister represents a Register event raised by the Whitelist contract.

type WhitelistRegisterIterator 

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

WhitelistRegisterIterator is returned from FilterRegister and is used to iterate over the raw logs and unpacked data for Register events raised by the Whitelist contract.

func (*WhitelistRegisterIterator) Close 

func (it *WhitelistRegisterIterator) Close() error

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

func (*WhitelistRegisterIterator) Error 

func (it *WhitelistRegisterIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*WhitelistRegisterIterator) Next 

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

type WhitelistSession 

type WhitelistSession struct {
	Contract     *Whitelist        // 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
}

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

func (*WhitelistSession) IsRegistered 

func (_Whitelist *WhitelistSession) IsRegistered(addr common.Address) (bool, error)

IsRegistered is a free data retrieval call binding the contract method 0xc3c5a547.

Solidity: function isRegistered(address addr) constant returns(bool)

func (*WhitelistSession) Register 

func (_Whitelist *WhitelistSession) Register(addr common.Address) (*types.Transaction, error)

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

Solidity: function register(address addr) returns()

type WhitelistTransactor 

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

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

func NewWhitelistTransactor 

func NewWhitelistTransactor(address common.Address, transactor bind.ContractTransactor) (*WhitelistTransactor, error)

NewWhitelistTransactor creates a new write-only instance of Whitelist, bound to a specific deployed contract.

func (*WhitelistTransactor) Register 

func (_Whitelist *WhitelistTransactor) Register(opts *bind.TransactOpts, addr common.Address) (*types.Transaction, error)

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

Solidity: function register(address addr) returns()

type WhitelistTransactorRaw 

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

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

func (*WhitelistTransactorRaw) Transact 

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

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

func (*WhitelistTransactorRaw) Transfer 

func (_Whitelist *WhitelistTransactorRaw) 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 WhitelistTransactorSession 

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

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

func (*WhitelistTransactorSession) Register 

func (_Whitelist *WhitelistTransactorSession) Register(addr common.Address) (*types.Transaction, error)

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

Solidity: function register(address addr) returns()

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.