DisableId

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

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

View Source 
const DisableIdBin = `` /* 5776-byte string literal not displayed */

DisableIdBin 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 = `` /* 1304-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 = `` /* 318-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 = `` /* 450-byte string literal not displayed */

MimcUnitBin is the compiled bytecode used for deploying new contracts.

Variables

This section is empty.

Functions

This section is empty.

Types

type DisableId 

type DisableId struct {
	DisableIdCaller     // Read-only binding to the contract
	DisableIdTransactor // Write-only binding to the contract
	DisableIdFilterer   // Log filterer for contract events
}

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

func DeployDisableId 

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

DeployDisableId deploys a new Ethereum contract, binding an instance of DisableId to it.

func NewDisableId 

func NewDisableId(address common.Address, backend bind.ContractBackend) (*DisableId, error)

NewDisableId creates a new instance of DisableId, bound to a specific deployed contract.

type DisableIdCaller 

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

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

func NewDisableIdCaller 

func NewDisableIdCaller(address common.Address, caller bind.ContractCaller) (*DisableIdCaller, error)

NewDisableIdCaller creates a new read-only instance of DisableId, bound to a specific deployed contract.

func (*DisableIdCaller) CheckSig 

func (_DisableId *DisableIdCaller) 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 (*DisableIdCaller) DisableList 

func (_DisableId *DisableIdCaller) DisableList(opts *bind.CallOpts, arg0 [31]byte) (bool, error)

DisableList is a free data retrieval call binding the contract method 0x00dc8cdc.

Solidity: function disableList(bytes31 ) constant returns(bool)

func (*DisableIdCaller) GetRootFromId 

func (_DisableId *DisableIdCaller) 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 DisableIdCallerRaw 

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

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

func (*DisableIdCallerRaw) Call 

func (_DisableId *DisableIdCallerRaw) 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 DisableIdCallerSession 

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

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

func (*DisableIdCallerSession) CheckSig 

func (_DisableId *DisableIdCallerSession) 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 (*DisableIdCallerSession) DisableList 

func (_DisableId *DisableIdCallerSession) DisableList(arg0 [31]byte) (bool, error)

DisableList is a free data retrieval call binding the contract method 0x00dc8cdc.

Solidity: function disableList(bytes31 ) constant returns(bool)

func (*DisableIdCallerSession) GetRootFromId 

func (_DisableId *DisableIdCallerSession) 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 DisableIdDisableIdEvent 

type DisableIdDisableIdEvent struct {
	Id  [31]byte
	Raw types.Log // Blockchain specific contextual infos
}

DisableIdDisableIdEvent represents a DisableIdEvent event raised by the DisableId contract.

type DisableIdDisableIdEventIterator 

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

DisableIdDisableIdEventIterator is returned from FilterDisableIdEvent and is used to iterate over the raw logs and unpacked data for DisableIdEvent events raised by the DisableId contract.

func (*DisableIdDisableIdEventIterator) Close 

func (it *DisableIdDisableIdEventIterator) Close() error

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

func (*DisableIdDisableIdEventIterator) Error 

func (it *DisableIdDisableIdEventIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DisableIdDisableIdEventIterator) Next 

func (it *DisableIdDisableIdEventIterator) 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 DisableIdFilterer 

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

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

func NewDisableIdFilterer 

func NewDisableIdFilterer(address common.Address, filterer bind.ContractFilterer) (*DisableIdFilterer, error)

NewDisableIdFilterer creates a new log filterer instance of DisableId, bound to a specific deployed contract.

func (*DisableIdFilterer) FilterDisableIdEvent 

func (_DisableId *DisableIdFilterer) FilterDisableIdEvent(opts *bind.FilterOpts) (*DisableIdDisableIdEventIterator, error)

FilterDisableIdEvent is a free log retrieval operation binding the contract event 0xad7c8149a76b6522635bb10cf23aa364e427591e066be8eab4474491eb2c479d.

Solidity: event disableIdEvent(bytes31 id)

func (*DisableIdFilterer) WatchDisableIdEvent 

func (_DisableId *DisableIdFilterer) WatchDisableIdEvent(opts *bind.WatchOpts, sink chan<- *DisableIdDisableIdEvent) (event.Subscription, error)

WatchDisableIdEvent is a free log subscription operation binding the contract event 0xad7c8149a76b6522635bb10cf23aa364e427591e066be8eab4474491eb2c479d.

Solidity: event disableIdEvent(bytes31 id)

type DisableIdRaw 

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

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

func (*DisableIdRaw) Call 

func (_DisableId *DisableIdRaw) 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 (*DisableIdRaw) Transact 

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

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

func (*DisableIdRaw) Transfer 

func (_DisableId *DisableIdRaw) 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 DisableIdSession 

type DisableIdSession struct {
	Contract     *DisableId        // 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
}

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

func (*DisableIdSession) CheckSig 

func (_DisableId *DisableIdSession) 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 (*DisableIdSession) DisableIdentity 

func (_DisableId *DisableIdSession) DisableIdentity(mtp []byte, id [31]byte, ethAddress common.Address, msgHash [32]byte, rsv []byte) (*types.Transaction, error)

DisableIdentity is a paid mutator transaction binding the contract method 0x49e9d2a3.

Solidity: function disableIdentity(bytes mtp, bytes31 id, address ethAddress, bytes32 msgHash, bytes rsv) returns()

func (*DisableIdSession) DisableList 

func (_DisableId *DisableIdSession) DisableList(arg0 [31]byte) (bool, error)

DisableList is a free data retrieval call binding the contract method 0x00dc8cdc.

Solidity: function disableList(bytes31 ) constant returns(bool)

func (*DisableIdSession) GetRootFromId 

func (_DisableId *DisableIdSession) 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 DisableIdTransactor 

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

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

func NewDisableIdTransactor 

func NewDisableIdTransactor(address common.Address, transactor bind.ContractTransactor) (*DisableIdTransactor, error)

NewDisableIdTransactor creates a new write-only instance of DisableId, bound to a specific deployed contract.

func (*DisableIdTransactor) DisableIdentity 

func (_DisableId *DisableIdTransactor) DisableIdentity(opts *bind.TransactOpts, mtp []byte, id [31]byte, ethAddress common.Address, msgHash [32]byte, rsv []byte) (*types.Transaction, error)

DisableIdentity is a paid mutator transaction binding the contract method 0x49e9d2a3.

Solidity: function disableIdentity(bytes mtp, bytes31 id, address ethAddress, bytes32 msgHash, bytes rsv) returns()

type DisableIdTransactorRaw 

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

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

func (*DisableIdTransactorRaw) Transact 

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

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

func (*DisableIdTransactorRaw) Transfer 

func (_DisableId *DisableIdTransactorRaw) 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 DisableIdTransactorSession 

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

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

func (*DisableIdTransactorSession) DisableIdentity 

func (_DisableId *DisableIdTransactorSession) DisableIdentity(mtp []byte, id [31]byte, ethAddress common.Address, msgHash [32]byte, rsv []byte) (*types.Transaction, error)

DisableIdentity is a paid mutator transaction binding the contract method 0x49e9d2a3.

Solidity: function disableIdentity(bytes mtp, bytes31 id, address ethAddress, bytes32 msgHash, bytes rsv) 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.

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.