contracts

package
v0.0.6 Latest Latest
Warning

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

 Go to latest Published: Jul 9, 2019 License: GPL-3.0 Imports: 8 Imported by: 0

Documentation

Index

Constants

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 = `` /* 1200-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 = `` /* 224-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 = `` /* 356-byte string literal not displayed */

MimcUnitBin 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 = `` /* 9292-byte string literal not displayed */

RootCommitsBin is the compiled bytecode used for deploying new contracts.

Variables

This section is empty.

Functions

This section is empty.

Types

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

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.