contracts

package
v1.0.1 Latest Latest
Warning

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

 Go to latest Published: Oct 12, 2020 License: MIT Imports: 9 Imported by: 0

Documentation

Index

Constants

View Source 
const GravityABI = "" /* 2101-byte string literal not displayed */

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

View Source 
const ISubscriberBytesABI = "" /* 180-byte string literal not displayed */

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

View Source 
const ISubscriberIntABI = "" /* 180-byte string literal not displayed */

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

View Source 
const ISubscriberStringABI = "" /* 182-byte string literal not displayed */

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

View Source 
const NModelsABI = "[]"

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

View Source 
const NebulaABI = "" /* 6956-byte string literal not displayed */

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

View Source 
const QueueLibABI = "[]"

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

Variables

View Source 
var (
	ErrParseExtractorType = errors.New("invalid parse extractor type")
)
View Source 
var GravityBin = "" /* 5568-byte string literal not displayed */

GravityBin is the compiled bytecode used for deploying new contracts.

View Source 
var GravityFuncSigs = map[string]string{
	"3cec1bdd": "bftValue()",
	"ad595b1a": "getConsuls()",
	"fe7378bb": "getConsulsByRoundId(uint256)",
	"c85f8d33": "hashNewConsuls(address[],uint256)",
	"82bc07e6": "lastRound()",
	"e6da9213": "rounds(uint256,uint256)",
	"92c388ab": "updateConsuls(address[],uint8[],bytes32[],bytes32[],uint256)",
}

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

View Source 
var ISubscriberBytesFuncSigs = map[string]string{
	"cc32a151": "attachValue(bytes)",
}

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

View Source 
var ISubscriberIntFuncSigs = map[string]string{
	"7dc7c1b0": "attachValue(int64)",
}

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

View Source 
var ISubscriberStringFuncSigs = map[string]string{
	"bb327823": "attachValue(string)",
}

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

View Source 
var NModelsBin = "" /* 244-byte string literal not displayed */

NModelsBin is the compiled bytecode used for deploying new contracts.

View Source 
var NebulaBin = "" /* 14080-byte string literal not displayed */

NebulaBin is the compiled bytecode used for deploying new contracts.

View Source 
var NebulaFuncSigs = map[string]string{
	"3cec1bdd": "bftValue()",
	"6175ff00": "dataType()",
	"40884c52": "getOracles()",
	"9505f6d4": "getSubscribersIds()",
	"770e58d5": "gravityContract()",
	"8bec345f": "hashNewOracles(address[])",
	"6148d3f3": "isPublseSubSent(uint256,bytes32)",
	"8d00662b": "lastPulseId()",
	"69a4246d": "oracleQueue()",
	"5b69a7d8": "oracles(uint256)",
	"1d11f944": "pulseQueue()",
	"0694fbb3": "pulses(uint256)",
	"8c65c81f": "rounds(uint256)",
	"bf2c0c42": "sendHashValue(bytes32,uint8[],bytes32[],bytes32[])",
	"ac557141": "sendValueToSubByte(bytes,uint256,bytes32)",
	"ff51063b": "sendValueToSubInt(int64,uint256,bytes32)",
	"9f95e525": "sendValueToSubString(string,uint256,bytes32)",
	"3527715d": "subscribe(address,uint8,uint256)",
	"8cafc358": "subscriptionIds(uint256)",
	"94259c6c": "subscriptions(bytes32)",
	"b48a9c9b": "subscriptionsQueue()",
	"febae9ea": "updateOracles(address[],uint8[],bytes32[],bytes32[],uint256)",
}

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

View Source 
var QueueLibBin = "" /* 1094-byte string literal not displayed */

QueueLibBin is the compiled bytecode used for deploying new contracts.

View Source 
var QueueLibFuncSigs = map[string]string{
	"9d6ad84b": "drop(QueueLib.Queue storage,bytes32)",
	"870a61ff": "next(QueueLib.Queue storage,bytes32)",
	"a506d954": "push(QueueLib.Queue storage,bytes32)",
}

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

Functions

This section is empty.

Types

type ExtractorType 

type ExtractorType uint8
const (
	Int64Type ExtractorType = iota
	StringType
	BytesType
)

func ParseExtractorType 

func ParseExtractorType(extractorType string) (ExtractorType, error)

type Gravity 

type Gravity struct {
	GravityCaller     // Read-only binding to the contract
	GravityTransactor // Write-only binding to the contract
	GravityFilterer   // Log filterer for contract events
}

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

func DeployGravity 

func DeployGravity(auth *bind.TransactOpts, backend bind.ContractBackend, consuls []common.Address, newBftValue *big.Int) (common.Address, *types.Transaction, *Gravity, error)

DeployGravity deploys a new Ethereum contract, binding an instance of Gravity to it.

func NewGravity 

func NewGravity(address common.Address, backend bind.ContractBackend) (*Gravity, error)

NewGravity creates a new instance of Gravity, bound to a specific deployed contract.

type GravityCaller 

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

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

func NewGravityCaller 

func NewGravityCaller(address common.Address, caller bind.ContractCaller) (*GravityCaller, error)

NewGravityCaller creates a new read-only instance of Gravity, bound to a specific deployed contract.

func (*GravityCaller) BftValue 

func (_Gravity *GravityCaller) BftValue(opts *bind.CallOpts) (*big.Int, error)

BftValue is a free data retrieval call binding the contract method 0x3cec1bdd.

Solidity: function bftValue() view returns(uint256)

func (*GravityCaller) GetConsuls 

func (_Gravity *GravityCaller) GetConsuls(opts *bind.CallOpts) ([]common.Address, error)

GetConsuls is a free data retrieval call binding the contract method 0xad595b1a.

Solidity: function getConsuls() view returns(address[])

func (*GravityCaller) GetConsulsByRoundId 

func (_Gravity *GravityCaller) GetConsulsByRoundId(opts *bind.CallOpts, roundId *big.Int) ([]common.Address, error)

GetConsulsByRoundId is a free data retrieval call binding the contract method 0xfe7378bb.

Solidity: function getConsulsByRoundId(uint256 roundId) view returns(address[])

func (*GravityCaller) HashNewConsuls 

func (_Gravity *GravityCaller) HashNewConsuls(opts *bind.CallOpts, newConsuls []common.Address, roundId *big.Int) ([32]byte, error)

HashNewConsuls is a free data retrieval call binding the contract method 0xc85f8d33.

Solidity: function hashNewConsuls(address[] newConsuls, uint256 roundId) pure returns(bytes32)

func (*GravityCaller) LastRound 

func (_Gravity *GravityCaller) LastRound(opts *bind.CallOpts) (*big.Int, error)

LastRound is a free data retrieval call binding the contract method 0x82bc07e6.

Solidity: function lastRound() view returns(uint256)

func (*GravityCaller) Rounds 

func (_Gravity *GravityCaller) Rounds(opts *bind.CallOpts, arg0 *big.Int, arg1 *big.Int) (common.Address, error)

Rounds is a free data retrieval call binding the contract method 0xe6da9213.

Solidity: function rounds(uint256 , uint256 ) view returns(address)

type GravityCallerRaw 

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

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

func (*GravityCallerRaw) Call 

func (_Gravity *GravityCallerRaw) 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 GravityCallerSession 

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

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

func (*GravityCallerSession) BftValue 

func (_Gravity *GravityCallerSession) BftValue() (*big.Int, error)

BftValue is a free data retrieval call binding the contract method 0x3cec1bdd.

Solidity: function bftValue() view returns(uint256)

func (*GravityCallerSession) GetConsuls 

func (_Gravity *GravityCallerSession) GetConsuls() ([]common.Address, error)

GetConsuls is a free data retrieval call binding the contract method 0xad595b1a.

Solidity: function getConsuls() view returns(address[])

func (*GravityCallerSession) GetConsulsByRoundId 

func (_Gravity *GravityCallerSession) GetConsulsByRoundId(roundId *big.Int) ([]common.Address, error)

GetConsulsByRoundId is a free data retrieval call binding the contract method 0xfe7378bb.

Solidity: function getConsulsByRoundId(uint256 roundId) view returns(address[])

func (*GravityCallerSession) HashNewConsuls 

func (_Gravity *GravityCallerSession) HashNewConsuls(newConsuls []common.Address, roundId *big.Int) ([32]byte, error)

HashNewConsuls is a free data retrieval call binding the contract method 0xc85f8d33.

Solidity: function hashNewConsuls(address[] newConsuls, uint256 roundId) pure returns(bytes32)

func (*GravityCallerSession) LastRound 

func (_Gravity *GravityCallerSession) LastRound() (*big.Int, error)

LastRound is a free data retrieval call binding the contract method 0x82bc07e6.

Solidity: function lastRound() view returns(uint256)

func (*GravityCallerSession) Rounds 

func (_Gravity *GravityCallerSession) Rounds(arg0 *big.Int, arg1 *big.Int) (common.Address, error)

Rounds is a free data retrieval call binding the contract method 0xe6da9213.

Solidity: function rounds(uint256 , uint256 ) view returns(address)

type GravityFilterer 

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

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

func NewGravityFilterer 

func NewGravityFilterer(address common.Address, filterer bind.ContractFilterer) (*GravityFilterer, error)

NewGravityFilterer creates a new log filterer instance of Gravity, bound to a specific deployed contract.

type GravityRaw 

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

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

func (*GravityRaw) Call 

func (_Gravity *GravityRaw) 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 (*GravityRaw) Transact 

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

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

func (*GravityRaw) Transfer 

func (_Gravity *GravityRaw) 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 GravitySession 

type GravitySession struct {
	Contract     *Gravity          // 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
}

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

func (*GravitySession) BftValue 

func (_Gravity *GravitySession) BftValue() (*big.Int, error)

BftValue is a free data retrieval call binding the contract method 0x3cec1bdd.

Solidity: function bftValue() view returns(uint256)

func (*GravitySession) GetConsuls 

func (_Gravity *GravitySession) GetConsuls() ([]common.Address, error)

GetConsuls is a free data retrieval call binding the contract method 0xad595b1a.

Solidity: function getConsuls() view returns(address[])

func (*GravitySession) GetConsulsByRoundId 

func (_Gravity *GravitySession) GetConsulsByRoundId(roundId *big.Int) ([]common.Address, error)

GetConsulsByRoundId is a free data retrieval call binding the contract method 0xfe7378bb.

Solidity: function getConsulsByRoundId(uint256 roundId) view returns(address[])

func (*GravitySession) HashNewConsuls 

func (_Gravity *GravitySession) HashNewConsuls(newConsuls []common.Address, roundId *big.Int) ([32]byte, error)

HashNewConsuls is a free data retrieval call binding the contract method 0xc85f8d33.

Solidity: function hashNewConsuls(address[] newConsuls, uint256 roundId) pure returns(bytes32)

func (*GravitySession) LastRound 

func (_Gravity *GravitySession) LastRound() (*big.Int, error)

LastRound is a free data retrieval call binding the contract method 0x82bc07e6.

Solidity: function lastRound() view returns(uint256)

func (*GravitySession) Rounds 

func (_Gravity *GravitySession) Rounds(arg0 *big.Int, arg1 *big.Int) (common.Address, error)

Rounds is a free data retrieval call binding the contract method 0xe6da9213.

Solidity: function rounds(uint256 , uint256 ) view returns(address)

func (*GravitySession) UpdateConsuls 

func (_Gravity *GravitySession) UpdateConsuls(newConsuls []common.Address, v []uint8, r [][32]byte, s [][32]byte, roundId *big.Int) (*types.Transaction, error)

UpdateConsuls is a paid mutator transaction binding the contract method 0x92c388ab.

Solidity: function updateConsuls(address[] newConsuls, uint8[] v, bytes32[] r, bytes32[] s, uint256 roundId) returns()

type GravityTransactor 

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

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

func NewGravityTransactor 

func NewGravityTransactor(address common.Address, transactor bind.ContractTransactor) (*GravityTransactor, error)

NewGravityTransactor creates a new write-only instance of Gravity, bound to a specific deployed contract.

func (*GravityTransactor) UpdateConsuls 

func (_Gravity *GravityTransactor) UpdateConsuls(opts *bind.TransactOpts, newConsuls []common.Address, v []uint8, r [][32]byte, s [][32]byte, roundId *big.Int) (*types.Transaction, error)

UpdateConsuls is a paid mutator transaction binding the contract method 0x92c388ab.

Solidity: function updateConsuls(address[] newConsuls, uint8[] v, bytes32[] r, bytes32[] s, uint256 roundId) returns()

type GravityTransactorRaw 

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

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

func (*GravityTransactorRaw) Transact 

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

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

func (*GravityTransactorRaw) Transfer 

func (_Gravity *GravityTransactorRaw) 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 GravityTransactorSession 

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

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

func (*GravityTransactorSession) UpdateConsuls 

func (_Gravity *GravityTransactorSession) UpdateConsuls(newConsuls []common.Address, v []uint8, r [][32]byte, s [][32]byte, roundId *big.Int) (*types.Transaction, error)

UpdateConsuls is a paid mutator transaction binding the contract method 0x92c388ab.

Solidity: function updateConsuls(address[] newConsuls, uint8[] v, bytes32[] r, bytes32[] s, uint256 roundId) returns()

type ISubscriberBytes 

type ISubscriberBytes struct {
	ISubscriberBytesCaller     // Read-only binding to the contract
	ISubscriberBytesTransactor // Write-only binding to the contract
	ISubscriberBytesFilterer   // Log filterer for contract events
}

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

func NewISubscriberBytes 

func NewISubscriberBytes(address common.Address, backend bind.ContractBackend) (*ISubscriberBytes, error)

NewISubscriberBytes creates a new instance of ISubscriberBytes, bound to a specific deployed contract.

type ISubscriberBytesCaller 

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

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

func NewISubscriberBytesCaller 

func NewISubscriberBytesCaller(address common.Address, caller bind.ContractCaller) (*ISubscriberBytesCaller, error)

NewISubscriberBytesCaller creates a new read-only instance of ISubscriberBytes, bound to a specific deployed contract.

type ISubscriberBytesCallerRaw 

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

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

func (*ISubscriberBytesCallerRaw) Call 

func (_ISubscriberBytes *ISubscriberBytesCallerRaw) 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 ISubscriberBytesCallerSession 

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

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

type ISubscriberBytesFilterer 

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

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

func NewISubscriberBytesFilterer 

func NewISubscriberBytesFilterer(address common.Address, filterer bind.ContractFilterer) (*ISubscriberBytesFilterer, error)

NewISubscriberBytesFilterer creates a new log filterer instance of ISubscriberBytes, bound to a specific deployed contract.

type ISubscriberBytesRaw 

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

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

func (*ISubscriberBytesRaw) Call 

func (_ISubscriberBytes *ISubscriberBytesRaw) 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 (*ISubscriberBytesRaw) Transact 

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

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

func (*ISubscriberBytesRaw) Transfer 

func (_ISubscriberBytes *ISubscriberBytesRaw) 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 ISubscriberBytesSession 

type ISubscriberBytesSession struct {
	Contract     *ISubscriberBytes // 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
}

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

func (*ISubscriberBytesSession) AttachValue 

func (_ISubscriberBytes *ISubscriberBytesSession) AttachValue(value []byte) (*types.Transaction, error)

AttachValue is a paid mutator transaction binding the contract method 0xcc32a151.

Solidity: function attachValue(bytes value) returns()

type ISubscriberBytesTransactor 

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

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

func NewISubscriberBytesTransactor 

func NewISubscriberBytesTransactor(address common.Address, transactor bind.ContractTransactor) (*ISubscriberBytesTransactor, error)

NewISubscriberBytesTransactor creates a new write-only instance of ISubscriberBytes, bound to a specific deployed contract.

func (*ISubscriberBytesTransactor) AttachValue 

func (_ISubscriberBytes *ISubscriberBytesTransactor) AttachValue(opts *bind.TransactOpts, value []byte) (*types.Transaction, error)

AttachValue is a paid mutator transaction binding the contract method 0xcc32a151.

Solidity: function attachValue(bytes value) returns()

type ISubscriberBytesTransactorRaw 

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

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

func (*ISubscriberBytesTransactorRaw) Transact 

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

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

func (*ISubscriberBytesTransactorRaw) Transfer 

func (_ISubscriberBytes *ISubscriberBytesTransactorRaw) 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 ISubscriberBytesTransactorSession 

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

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

func (*ISubscriberBytesTransactorSession) AttachValue 

func (_ISubscriberBytes *ISubscriberBytesTransactorSession) AttachValue(value []byte) (*types.Transaction, error)

AttachValue is a paid mutator transaction binding the contract method 0xcc32a151.

Solidity: function attachValue(bytes value) returns()

type ISubscriberInt 

type ISubscriberInt struct {
	ISubscriberIntCaller     // Read-only binding to the contract
	ISubscriberIntTransactor // Write-only binding to the contract
	ISubscriberIntFilterer   // Log filterer for contract events
}

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

func NewISubscriberInt 

func NewISubscriberInt(address common.Address, backend bind.ContractBackend) (*ISubscriberInt, error)

NewISubscriberInt creates a new instance of ISubscriberInt, bound to a specific deployed contract.

type ISubscriberIntCaller 

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

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

func NewISubscriberIntCaller 

func NewISubscriberIntCaller(address common.Address, caller bind.ContractCaller) (*ISubscriberIntCaller, error)

NewISubscriberIntCaller creates a new read-only instance of ISubscriberInt, bound to a specific deployed contract.

type ISubscriberIntCallerRaw 

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

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

func (*ISubscriberIntCallerRaw) Call 

func (_ISubscriberInt *ISubscriberIntCallerRaw) 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 ISubscriberIntCallerSession 

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

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

type ISubscriberIntFilterer 

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

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

func NewISubscriberIntFilterer 

func NewISubscriberIntFilterer(address common.Address, filterer bind.ContractFilterer) (*ISubscriberIntFilterer, error)

NewISubscriberIntFilterer creates a new log filterer instance of ISubscriberInt, bound to a specific deployed contract.

type ISubscriberIntRaw 

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

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

func (*ISubscriberIntRaw) Call 

func (_ISubscriberInt *ISubscriberIntRaw) 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 (*ISubscriberIntRaw) Transact 

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

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

func (*ISubscriberIntRaw) Transfer 

func (_ISubscriberInt *ISubscriberIntRaw) 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 ISubscriberIntSession 

type ISubscriberIntSession struct {
	Contract     *ISubscriberInt   // 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
}

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

func (*ISubscriberIntSession) AttachValue 

func (_ISubscriberInt *ISubscriberIntSession) AttachValue(value int64) (*types.Transaction, error)

AttachValue is a paid mutator transaction binding the contract method 0x7dc7c1b0.

Solidity: function attachValue(int64 value) returns()

type ISubscriberIntTransactor 

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

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

func NewISubscriberIntTransactor 

func NewISubscriberIntTransactor(address common.Address, transactor bind.ContractTransactor) (*ISubscriberIntTransactor, error)

NewISubscriberIntTransactor creates a new write-only instance of ISubscriberInt, bound to a specific deployed contract.

func (*ISubscriberIntTransactor) AttachValue 

func (_ISubscriberInt *ISubscriberIntTransactor) AttachValue(opts *bind.TransactOpts, value int64) (*types.Transaction, error)

AttachValue is a paid mutator transaction binding the contract method 0x7dc7c1b0.

Solidity: function attachValue(int64 value) returns()

type ISubscriberIntTransactorRaw 

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

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

func (*ISubscriberIntTransactorRaw) Transact 

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

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

func (*ISubscriberIntTransactorRaw) Transfer 

func (_ISubscriberInt *ISubscriberIntTransactorRaw) 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 ISubscriberIntTransactorSession 

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

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

func (*ISubscriberIntTransactorSession) AttachValue 

func (_ISubscriberInt *ISubscriberIntTransactorSession) AttachValue(value int64) (*types.Transaction, error)

AttachValue is a paid mutator transaction binding the contract method 0x7dc7c1b0.

Solidity: function attachValue(int64 value) returns()

type ISubscriberString 

type ISubscriberString struct {
	ISubscriberStringCaller     // Read-only binding to the contract
	ISubscriberStringTransactor // Write-only binding to the contract
	ISubscriberStringFilterer   // Log filterer for contract events
}

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

func NewISubscriberString 

func NewISubscriberString(address common.Address, backend bind.ContractBackend) (*ISubscriberString, error)

NewISubscriberString creates a new instance of ISubscriberString, bound to a specific deployed contract.

type ISubscriberStringCaller 

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

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

func NewISubscriberStringCaller 

func NewISubscriberStringCaller(address common.Address, caller bind.ContractCaller) (*ISubscriberStringCaller, error)

NewISubscriberStringCaller creates a new read-only instance of ISubscriberString, bound to a specific deployed contract.

type ISubscriberStringCallerRaw 

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

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

func (*ISubscriberStringCallerRaw) Call 

func (_ISubscriberString *ISubscriberStringCallerRaw) 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 ISubscriberStringCallerSession 

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

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

type ISubscriberStringFilterer 

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

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

func NewISubscriberStringFilterer 

func NewISubscriberStringFilterer(address common.Address, filterer bind.ContractFilterer) (*ISubscriberStringFilterer, error)

NewISubscriberStringFilterer creates a new log filterer instance of ISubscriberString, bound to a specific deployed contract.

type ISubscriberStringRaw 

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

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

func (*ISubscriberStringRaw) Call 

func (_ISubscriberString *ISubscriberStringRaw) 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 (*ISubscriberStringRaw) Transact 

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

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

func (*ISubscriberStringRaw) Transfer 

func (_ISubscriberString *ISubscriberStringRaw) 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 ISubscriberStringSession 

type ISubscriberStringSession struct {
	Contract     *ISubscriberString // 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
}

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

func (*ISubscriberStringSession) AttachValue 

func (_ISubscriberString *ISubscriberStringSession) AttachValue(value string) (*types.Transaction, error)

AttachValue is a paid mutator transaction binding the contract method 0xbb327823.

Solidity: function attachValue(string value) returns()

type ISubscriberStringTransactor 

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

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

func NewISubscriberStringTransactor 

func NewISubscriberStringTransactor(address common.Address, transactor bind.ContractTransactor) (*ISubscriberStringTransactor, error)

NewISubscriberStringTransactor creates a new write-only instance of ISubscriberString, bound to a specific deployed contract.

func (*ISubscriberStringTransactor) AttachValue 

func (_ISubscriberString *ISubscriberStringTransactor) AttachValue(opts *bind.TransactOpts, value string) (*types.Transaction, error)

AttachValue is a paid mutator transaction binding the contract method 0xbb327823.

Solidity: function attachValue(string value) returns()

type ISubscriberStringTransactorRaw 

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

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

func (*ISubscriberStringTransactorRaw) Transact 

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

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

func (*ISubscriberStringTransactorRaw) Transfer 

func (_ISubscriberString *ISubscriberStringTransactorRaw) 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 ISubscriberStringTransactorSession 

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

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

func (*ISubscriberStringTransactorSession) AttachValue 

func (_ISubscriberString *ISubscriberStringTransactorSession) AttachValue(value string) (*types.Transaction, error)

AttachValue is a paid mutator transaction binding the contract method 0xbb327823.

Solidity: function attachValue(string value) returns()

type NModels 

type NModels struct {
	NModelsCaller     // Read-only binding to the contract
	NModelsTransactor // Write-only binding to the contract
	NModelsFilterer   // Log filterer for contract events
}

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

func DeployNModels 

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

DeployNModels deploys a new Ethereum contract, binding an instance of NModels to it.

func NewNModels 

func NewNModels(address common.Address, backend bind.ContractBackend) (*NModels, error)

NewNModels creates a new instance of NModels, bound to a specific deployed contract.

type NModelsCaller 

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

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

func NewNModelsCaller 

func NewNModelsCaller(address common.Address, caller bind.ContractCaller) (*NModelsCaller, error)

NewNModelsCaller creates a new read-only instance of NModels, bound to a specific deployed contract.

type NModelsCallerRaw 

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

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

func (*NModelsCallerRaw) Call 

func (_NModels *NModelsCallerRaw) 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 NModelsCallerSession 

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

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

type NModelsFilterer 

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

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

func NewNModelsFilterer 

func NewNModelsFilterer(address common.Address, filterer bind.ContractFilterer) (*NModelsFilterer, error)

NewNModelsFilterer creates a new log filterer instance of NModels, bound to a specific deployed contract.

type NModelsRaw 

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

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

func (*NModelsRaw) Call 

func (_NModels *NModelsRaw) 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 (*NModelsRaw) Transact 

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

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

func (*NModelsRaw) Transfer 

func (_NModels *NModelsRaw) 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 NModelsSession 

type NModelsSession struct {
	Contract     *NModels          // 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
}

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

type NModelsTransactor 

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

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

func NewNModelsTransactor 

func NewNModelsTransactor(address common.Address, transactor bind.ContractTransactor) (*NModelsTransactor, error)

NewNModelsTransactor creates a new write-only instance of NModels, bound to a specific deployed contract.

type NModelsTransactorRaw 

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

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

func (*NModelsTransactorRaw) Transact 

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

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

func (*NModelsTransactorRaw) Transfer 

func (_NModels *NModelsTransactorRaw) 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 NModelsTransactorSession 

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

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

type Nebula 

type Nebula struct {
	NebulaCaller     // Read-only binding to the contract
	NebulaTransactor // Write-only binding to the contract
	NebulaFilterer   // Log filterer for contract events
}

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

func DeployNebula 

func DeployNebula(auth *bind.TransactOpts, backend bind.ContractBackend, newDataType uint8, newGravityContract common.Address, newOracle []common.Address, newBftValue *big.Int, subscriber common.Address) (common.Address, *types.Transaction, *Nebula, error)

DeployNebula deploys a new Ethereum contract, binding an instance of Nebula to it.

func NewNebula 

func NewNebula(address common.Address, backend bind.ContractBackend) (*Nebula, error)

NewNebula creates a new instance of Nebula, bound to a specific deployed contract.

type NebulaCaller 

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

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

func NewNebulaCaller 

func NewNebulaCaller(address common.Address, caller bind.ContractCaller) (*NebulaCaller, error)

NewNebulaCaller creates a new read-only instance of Nebula, bound to a specific deployed contract.

func (*NebulaCaller) BftValue 

func (_Nebula *NebulaCaller) BftValue(opts *bind.CallOpts) (*big.Int, error)

BftValue is a free data retrieval call binding the contract method 0x3cec1bdd.

Solidity: function bftValue() view returns(uint256)

func (*NebulaCaller) DataType 

func (_Nebula *NebulaCaller) DataType(opts *bind.CallOpts) (uint8, error)

DataType is a free data retrieval call binding the contract method 0x6175ff00.

Solidity: function dataType() view returns(uint8)

func (*NebulaCaller) GetOracles 

func (_Nebula *NebulaCaller) GetOracles(opts *bind.CallOpts) ([]common.Address, error)

GetOracles is a free data retrieval call binding the contract method 0x40884c52.

Solidity: function getOracles() view returns(address[])

func (*NebulaCaller) GetSubscribersIds 

func (_Nebula *NebulaCaller) GetSubscribersIds(opts *bind.CallOpts) ([][32]byte, error)

GetSubscribersIds is a free data retrieval call binding the contract method 0x9505f6d4.

Solidity: function getSubscribersIds() view returns(bytes32[])

func (*NebulaCaller) GravityContract 

func (_Nebula *NebulaCaller) GravityContract(opts *bind.CallOpts) (common.Address, error)

GravityContract is a free data retrieval call binding the contract method 0x770e58d5.

Solidity: function gravityContract() view returns(address)

func (*NebulaCaller) HashNewOracles 

func (_Nebula *NebulaCaller) HashNewOracles(opts *bind.CallOpts, newOracles []common.Address) ([32]byte, error)

HashNewOracles is a free data retrieval call binding the contract method 0x8bec345f.

Solidity: function hashNewOracles(address[] newOracles) pure returns(bytes32)

func (*NebulaCaller) IsPublseSubSent 

func (_Nebula *NebulaCaller) IsPublseSubSent(opts *bind.CallOpts, arg0 *big.Int, arg1 [32]byte) (bool, error)

IsPublseSubSent is a free data retrieval call binding the contract method 0x6148d3f3.

Solidity: function isPublseSubSent(uint256 , bytes32 ) view returns(bool)

func (*NebulaCaller) LastPulseId 

func (_Nebula *NebulaCaller) LastPulseId(opts *bind.CallOpts) (*big.Int, error)

LastPulseId is a free data retrieval call binding the contract method 0x8d00662b.

Solidity: function lastPulseId() view returns(uint256)

func (*NebulaCaller) OracleQueue 

func (_Nebula *NebulaCaller) OracleQueue(opts *bind.CallOpts) (struct {
	First [32]byte
	Last  [32]byte
}, error)

OracleQueue is a free data retrieval call binding the contract method 0x69a4246d.

Solidity: function oracleQueue() view returns(bytes32 first, bytes32 last)

func (*NebulaCaller) Oracles 

func (_Nebula *NebulaCaller) Oracles(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error)

Oracles is a free data retrieval call binding the contract method 0x5b69a7d8.

Solidity: function oracles(uint256 ) view returns(address)

func (*NebulaCaller) PulseQueue 

func (_Nebula *NebulaCaller) PulseQueue(opts *bind.CallOpts) (struct {
	First [32]byte
	Last  [32]byte
}, error)

PulseQueue is a free data retrieval call binding the contract method 0x1d11f944.

Solidity: function pulseQueue() view returns(bytes32 first, bytes32 last)

func (*NebulaCaller) Pulses 

func (_Nebula *NebulaCaller) Pulses(opts *bind.CallOpts, arg0 *big.Int) (struct {
	DataHash [32]byte
	Height   *big.Int
}, error)

Pulses is a free data retrieval call binding the contract method 0x0694fbb3.

Solidity: function pulses(uint256 ) view returns(bytes32 dataHash, uint256 height)

func (*NebulaCaller) Rounds 

func (_Nebula *NebulaCaller) Rounds(opts *bind.CallOpts, arg0 *big.Int) (bool, error)

Rounds is a free data retrieval call binding the contract method 0x8c65c81f.

Solidity: function rounds(uint256 ) view returns(bool)

func (*NebulaCaller) SubscriptionIds 

func (_Nebula *NebulaCaller) SubscriptionIds(opts *bind.CallOpts, arg0 *big.Int) ([32]byte, error)

SubscriptionIds is a free data retrieval call binding the contract method 0x8cafc358.

Solidity: function subscriptionIds(uint256 ) view returns(bytes32)

func (*NebulaCaller) Subscriptions 

func (_Nebula *NebulaCaller) Subscriptions(opts *bind.CallOpts, arg0 [32]byte) (struct {
	Owner            common.Address
	ContractAddress  common.Address
	MinConfirmations uint8
	Reward           *big.Int
}, error)

Subscriptions is a free data retrieval call binding the contract method 0x94259c6c.

Solidity: function subscriptions(bytes32 ) view returns(address owner, address contractAddress, uint8 minConfirmations, uint256 reward)

func (*NebulaCaller) SubscriptionsQueue 

func (_Nebula *NebulaCaller) SubscriptionsQueue(opts *bind.CallOpts) (struct {
	First [32]byte
	Last  [32]byte
}, error)

SubscriptionsQueue is a free data retrieval call binding the contract method 0xb48a9c9b.

Solidity: function subscriptionsQueue() view returns(bytes32 first, bytes32 last)

type NebulaCallerRaw 

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

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

func (*NebulaCallerRaw) Call 

func (_Nebula *NebulaCallerRaw) 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 NebulaCallerSession 

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

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

func (*NebulaCallerSession) BftValue 

func (_Nebula *NebulaCallerSession) BftValue() (*big.Int, error)

BftValue is a free data retrieval call binding the contract method 0x3cec1bdd.

Solidity: function bftValue() view returns(uint256)

func (*NebulaCallerSession) DataType 

func (_Nebula *NebulaCallerSession) DataType() (uint8, error)

DataType is a free data retrieval call binding the contract method 0x6175ff00.

Solidity: function dataType() view returns(uint8)

func (*NebulaCallerSession) GetOracles 

func (_Nebula *NebulaCallerSession) GetOracles() ([]common.Address, error)

GetOracles is a free data retrieval call binding the contract method 0x40884c52.

Solidity: function getOracles() view returns(address[])

func (*NebulaCallerSession) GetSubscribersIds 

func (_Nebula *NebulaCallerSession) GetSubscribersIds() ([][32]byte, error)

GetSubscribersIds is a free data retrieval call binding the contract method 0x9505f6d4.

Solidity: function getSubscribersIds() view returns(bytes32[])

func (*NebulaCallerSession) GravityContract 

func (_Nebula *NebulaCallerSession) GravityContract() (common.Address, error)

GravityContract is a free data retrieval call binding the contract method 0x770e58d5.

Solidity: function gravityContract() view returns(address)

func (*NebulaCallerSession) HashNewOracles 

func (_Nebula *NebulaCallerSession) HashNewOracles(newOracles []common.Address) ([32]byte, error)

HashNewOracles is a free data retrieval call binding the contract method 0x8bec345f.

Solidity: function hashNewOracles(address[] newOracles) pure returns(bytes32)

func (*NebulaCallerSession) IsPublseSubSent 

func (_Nebula *NebulaCallerSession) IsPublseSubSent(arg0 *big.Int, arg1 [32]byte) (bool, error)

IsPublseSubSent is a free data retrieval call binding the contract method 0x6148d3f3.

Solidity: function isPublseSubSent(uint256 , bytes32 ) view returns(bool)

func (*NebulaCallerSession) LastPulseId 

func (_Nebula *NebulaCallerSession) LastPulseId() (*big.Int, error)

LastPulseId is a free data retrieval call binding the contract method 0x8d00662b.

Solidity: function lastPulseId() view returns(uint256)

func (*NebulaCallerSession) OracleQueue 

func (_Nebula *NebulaCallerSession) OracleQueue() (struct {
	First [32]byte
	Last  [32]byte
}, error)

OracleQueue is a free data retrieval call binding the contract method 0x69a4246d.

Solidity: function oracleQueue() view returns(bytes32 first, bytes32 last)

func (*NebulaCallerSession) Oracles 

func (_Nebula *NebulaCallerSession) Oracles(arg0 *big.Int) (common.Address, error)

Oracles is a free data retrieval call binding the contract method 0x5b69a7d8.

Solidity: function oracles(uint256 ) view returns(address)

func (*NebulaCallerSession) PulseQueue 

func (_Nebula *NebulaCallerSession) PulseQueue() (struct {
	First [32]byte
	Last  [32]byte
}, error)

PulseQueue is a free data retrieval call binding the contract method 0x1d11f944.

Solidity: function pulseQueue() view returns(bytes32 first, bytes32 last)

func (*NebulaCallerSession) Pulses 

func (_Nebula *NebulaCallerSession) Pulses(arg0 *big.Int) (struct {
	DataHash [32]byte
	Height   *big.Int
}, error)

Pulses is a free data retrieval call binding the contract method 0x0694fbb3.

Solidity: function pulses(uint256 ) view returns(bytes32 dataHash, uint256 height)

func (*NebulaCallerSession) Rounds 

func (_Nebula *NebulaCallerSession) Rounds(arg0 *big.Int) (bool, error)

Rounds is a free data retrieval call binding the contract method 0x8c65c81f.

Solidity: function rounds(uint256 ) view returns(bool)

func (*NebulaCallerSession) SubscriptionIds 

func (_Nebula *NebulaCallerSession) SubscriptionIds(arg0 *big.Int) ([32]byte, error)

SubscriptionIds is a free data retrieval call binding the contract method 0x8cafc358.

Solidity: function subscriptionIds(uint256 ) view returns(bytes32)

func (*NebulaCallerSession) Subscriptions 

func (_Nebula *NebulaCallerSession) Subscriptions(arg0 [32]byte) (struct {
	Owner            common.Address
	ContractAddress  common.Address
	MinConfirmations uint8
	Reward           *big.Int
}, error)

Subscriptions is a free data retrieval call binding the contract method 0x94259c6c.

Solidity: function subscriptions(bytes32 ) view returns(address owner, address contractAddress, uint8 minConfirmations, uint256 reward)

func (*NebulaCallerSession) SubscriptionsQueue 

func (_Nebula *NebulaCallerSession) SubscriptionsQueue() (struct {
	First [32]byte
	Last  [32]byte
}, error)

SubscriptionsQueue is a free data retrieval call binding the contract method 0xb48a9c9b.

Solidity: function subscriptionsQueue() view returns(bytes32 first, bytes32 last)

type NebulaFilterer 

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

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

func NewNebulaFilterer 

func NewNebulaFilterer(address common.Address, filterer bind.ContractFilterer) (*NebulaFilterer, error)

NewNebulaFilterer creates a new log filterer instance of Nebula, bound to a specific deployed contract.

func (*NebulaFilterer) FilterNewPulse 

func (_Nebula *NebulaFilterer) FilterNewPulse(opts *bind.FilterOpts) (*NebulaNewPulseIterator, error)

FilterNewPulse is a free log retrieval operation binding the contract event 0x59327fa227d3fcc72b61eb5e7083cd72b448c22d7ea96849f4655db8de22d639.

Solidity: event NewPulse(uint256 pulseId, uint256 height, bytes32 dataHash)

func (*NebulaFilterer) ParseNewPulse 

func (_Nebula *NebulaFilterer) ParseNewPulse(log types.Log) (*NebulaNewPulse, error)

ParseNewPulse is a log parse operation binding the contract event 0x59327fa227d3fcc72b61eb5e7083cd72b448c22d7ea96849f4655db8de22d639.

Solidity: event NewPulse(uint256 pulseId, uint256 height, bytes32 dataHash)

func (*NebulaFilterer) WatchNewPulse 

func (_Nebula *NebulaFilterer) WatchNewPulse(opts *bind.WatchOpts, sink chan<- *NebulaNewPulse) (event.Subscription, error)

WatchNewPulse is a free log subscription operation binding the contract event 0x59327fa227d3fcc72b61eb5e7083cd72b448c22d7ea96849f4655db8de22d639.

Solidity: event NewPulse(uint256 pulseId, uint256 height, bytes32 dataHash)

type NebulaNewPulse 

type NebulaNewPulse struct {
	PulseId  *big.Int
	Height   *big.Int
	DataHash [32]byte
	Raw      types.Log // Blockchain specific contextual infos
}

NebulaNewPulse represents a NewPulse event raised by the Nebula contract.

type NebulaNewPulseIterator 

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

NebulaNewPulseIterator is returned from FilterNewPulse and is used to iterate over the raw logs and unpacked data for NewPulse events raised by the Nebula contract.

func (*NebulaNewPulseIterator) Close 

func (it *NebulaNewPulseIterator) Close() error

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

func (*NebulaNewPulseIterator) Error 

func (it *NebulaNewPulseIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*NebulaNewPulseIterator) Next 

func (it *NebulaNewPulseIterator) 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 NebulaRaw 

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

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

func (*NebulaRaw) Call 

func (_Nebula *NebulaRaw) 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 (*NebulaRaw) Transact 

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

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

func (*NebulaRaw) Transfer 

func (_Nebula *NebulaRaw) 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 NebulaSession 

type NebulaSession struct {
	Contract     *Nebula           // 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
}

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

func (*NebulaSession) BftValue 

func (_Nebula *NebulaSession) BftValue() (*big.Int, error)

BftValue is a free data retrieval call binding the contract method 0x3cec1bdd.

Solidity: function bftValue() view returns(uint256)

func (*NebulaSession) DataType 

func (_Nebula *NebulaSession) DataType() (uint8, error)

DataType is a free data retrieval call binding the contract method 0x6175ff00.

Solidity: function dataType() view returns(uint8)

func (*NebulaSession) GetOracles 

func (_Nebula *NebulaSession) GetOracles() ([]common.Address, error)

GetOracles is a free data retrieval call binding the contract method 0x40884c52.

Solidity: function getOracles() view returns(address[])

func (*NebulaSession) GetSubscribersIds 

func (_Nebula *NebulaSession) GetSubscribersIds() ([][32]byte, error)

GetSubscribersIds is a free data retrieval call binding the contract method 0x9505f6d4.

Solidity: function getSubscribersIds() view returns(bytes32[])

func (*NebulaSession) GravityContract 

func (_Nebula *NebulaSession) GravityContract() (common.Address, error)

GravityContract is a free data retrieval call binding the contract method 0x770e58d5.

Solidity: function gravityContract() view returns(address)

func (*NebulaSession) HashNewOracles 

func (_Nebula *NebulaSession) HashNewOracles(newOracles []common.Address) ([32]byte, error)

HashNewOracles is a free data retrieval call binding the contract method 0x8bec345f.

Solidity: function hashNewOracles(address[] newOracles) pure returns(bytes32)

func (*NebulaSession) IsPublseSubSent 

func (_Nebula *NebulaSession) IsPublseSubSent(arg0 *big.Int, arg1 [32]byte) (bool, error)

IsPublseSubSent is a free data retrieval call binding the contract method 0x6148d3f3.

Solidity: function isPublseSubSent(uint256 , bytes32 ) view returns(bool)

func (*NebulaSession) LastPulseId 

func (_Nebula *NebulaSession) LastPulseId() (*big.Int, error)

LastPulseId is a free data retrieval call binding the contract method 0x8d00662b.

Solidity: function lastPulseId() view returns(uint256)

func (*NebulaSession) OracleQueue 

func (_Nebula *NebulaSession) OracleQueue() (struct {
	First [32]byte
	Last  [32]byte
}, error)

OracleQueue is a free data retrieval call binding the contract method 0x69a4246d.

Solidity: function oracleQueue() view returns(bytes32 first, bytes32 last)

func (*NebulaSession) Oracles 

func (_Nebula *NebulaSession) Oracles(arg0 *big.Int) (common.Address, error)

Oracles is a free data retrieval call binding the contract method 0x5b69a7d8.

Solidity: function oracles(uint256 ) view returns(address)

func (*NebulaSession) PulseQueue 

func (_Nebula *NebulaSession) PulseQueue() (struct {
	First [32]byte
	Last  [32]byte
}, error)

PulseQueue is a free data retrieval call binding the contract method 0x1d11f944.

Solidity: function pulseQueue() view returns(bytes32 first, bytes32 last)

func (*NebulaSession) Pulses 

func (_Nebula *NebulaSession) Pulses(arg0 *big.Int) (struct {
	DataHash [32]byte
	Height   *big.Int
}, error)

Pulses is a free data retrieval call binding the contract method 0x0694fbb3.

Solidity: function pulses(uint256 ) view returns(bytes32 dataHash, uint256 height)

func (*NebulaSession) Receive 

func (_Nebula *NebulaSession) Receive() (*types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

func (*NebulaSession) Rounds 

func (_Nebula *NebulaSession) Rounds(arg0 *big.Int) (bool, error)

Rounds is a free data retrieval call binding the contract method 0x8c65c81f.

Solidity: function rounds(uint256 ) view returns(bool)

func (*NebulaSession) SendHashValue 

func (_Nebula *NebulaSession) SendHashValue(dataHash [32]byte, v []uint8, r [][32]byte, s [][32]byte) (*types.Transaction, error)

SendHashValue is a paid mutator transaction binding the contract method 0xbf2c0c42.

Solidity: function sendHashValue(bytes32 dataHash, uint8[] v, bytes32[] r, bytes32[] s) returns()

func (*NebulaSession) SendValueToSubByte 

func (_Nebula *NebulaSession) SendValueToSubByte(value []byte, pulseId *big.Int, subId [32]byte) (*types.Transaction, error)

SendValueToSubByte is a paid mutator transaction binding the contract method 0xac557141.

Solidity: function sendValueToSubByte(bytes value, uint256 pulseId, bytes32 subId) returns()

func (*NebulaSession) SendValueToSubInt 

func (_Nebula *NebulaSession) SendValueToSubInt(value int64, pulseId *big.Int, subId [32]byte) (*types.Transaction, error)

SendValueToSubInt is a paid mutator transaction binding the contract method 0xff51063b.

Solidity: function sendValueToSubInt(int64 value, uint256 pulseId, bytes32 subId) returns()

func (*NebulaSession) SendValueToSubString 

func (_Nebula *NebulaSession) SendValueToSubString(value string, pulseId *big.Int, subId [32]byte) (*types.Transaction, error)

SendValueToSubString is a paid mutator transaction binding the contract method 0x9f95e525.

Solidity: function sendValueToSubString(string value, uint256 pulseId, bytes32 subId) returns()

func (*NebulaSession) Subscribe 

func (_Nebula *NebulaSession) Subscribe(contractAddress common.Address, minConfirmations uint8, reward *big.Int) (*types.Transaction, error)

Subscribe is a paid mutator transaction binding the contract method 0x3527715d.

Solidity: function subscribe(address contractAddress, uint8 minConfirmations, uint256 reward) returns()

func (*NebulaSession) SubscriptionIds 

func (_Nebula *NebulaSession) SubscriptionIds(arg0 *big.Int) ([32]byte, error)

SubscriptionIds is a free data retrieval call binding the contract method 0x8cafc358.

Solidity: function subscriptionIds(uint256 ) view returns(bytes32)

func (*NebulaSession) Subscriptions 

func (_Nebula *NebulaSession) Subscriptions(arg0 [32]byte) (struct {
	Owner            common.Address
	ContractAddress  common.Address
	MinConfirmations uint8
	Reward           *big.Int
}, error)

Subscriptions is a free data retrieval call binding the contract method 0x94259c6c.

Solidity: function subscriptions(bytes32 ) view returns(address owner, address contractAddress, uint8 minConfirmations, uint256 reward)

func (*NebulaSession) SubscriptionsQueue 

func (_Nebula *NebulaSession) SubscriptionsQueue() (struct {
	First [32]byte
	Last  [32]byte
}, error)

SubscriptionsQueue is a free data retrieval call binding the contract method 0xb48a9c9b.

Solidity: function subscriptionsQueue() view returns(bytes32 first, bytes32 last)

func (*NebulaSession) UpdateOracles 

func (_Nebula *NebulaSession) UpdateOracles(newOracles []common.Address, v []uint8, r [][32]byte, s [][32]byte, newRound *big.Int) (*types.Transaction, error)

UpdateOracles is a paid mutator transaction binding the contract method 0xfebae9ea.

Solidity: function updateOracles(address[] newOracles, uint8[] v, bytes32[] r, bytes32[] s, uint256 newRound) returns()

type NebulaTransactor 

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

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

func NewNebulaTransactor 

func NewNebulaTransactor(address common.Address, transactor bind.ContractTransactor) (*NebulaTransactor, error)

NewNebulaTransactor creates a new write-only instance of Nebula, bound to a specific deployed contract.

func (*NebulaTransactor) Receive 

func (_Nebula *NebulaTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

func (*NebulaTransactor) SendHashValue 

func (_Nebula *NebulaTransactor) SendHashValue(opts *bind.TransactOpts, dataHash [32]byte, v []uint8, r [][32]byte, s [][32]byte) (*types.Transaction, error)

SendHashValue is a paid mutator transaction binding the contract method 0xbf2c0c42.

Solidity: function sendHashValue(bytes32 dataHash, uint8[] v, bytes32[] r, bytes32[] s) returns()

func (*NebulaTransactor) SendValueToSubByte 

func (_Nebula *NebulaTransactor) SendValueToSubByte(opts *bind.TransactOpts, value []byte, pulseId *big.Int, subId [32]byte) (*types.Transaction, error)

SendValueToSubByte is a paid mutator transaction binding the contract method 0xac557141.

Solidity: function sendValueToSubByte(bytes value, uint256 pulseId, bytes32 subId) returns()

func (*NebulaTransactor) SendValueToSubInt 

func (_Nebula *NebulaTransactor) SendValueToSubInt(opts *bind.TransactOpts, value int64, pulseId *big.Int, subId [32]byte) (*types.Transaction, error)

SendValueToSubInt is a paid mutator transaction binding the contract method 0xff51063b.

Solidity: function sendValueToSubInt(int64 value, uint256 pulseId, bytes32 subId) returns()

func (*NebulaTransactor) SendValueToSubString 

func (_Nebula *NebulaTransactor) SendValueToSubString(opts *bind.TransactOpts, value string, pulseId *big.Int, subId [32]byte) (*types.Transaction, error)

SendValueToSubString is a paid mutator transaction binding the contract method 0x9f95e525.

Solidity: function sendValueToSubString(string value, uint256 pulseId, bytes32 subId) returns()

func (*NebulaTransactor) Subscribe 

func (_Nebula *NebulaTransactor) Subscribe(opts *bind.TransactOpts, contractAddress common.Address, minConfirmations uint8, reward *big.Int) (*types.Transaction, error)

Subscribe is a paid mutator transaction binding the contract method 0x3527715d.

Solidity: function subscribe(address contractAddress, uint8 minConfirmations, uint256 reward) returns()

func (*NebulaTransactor) UpdateOracles 

func (_Nebula *NebulaTransactor) UpdateOracles(opts *bind.TransactOpts, newOracles []common.Address, v []uint8, r [][32]byte, s [][32]byte, newRound *big.Int) (*types.Transaction, error)

UpdateOracles is a paid mutator transaction binding the contract method 0xfebae9ea.

Solidity: function updateOracles(address[] newOracles, uint8[] v, bytes32[] r, bytes32[] s, uint256 newRound) returns()

type NebulaTransactorRaw 

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

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

func (*NebulaTransactorRaw) Transact 

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

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

func (*NebulaTransactorRaw) Transfer 

func (_Nebula *NebulaTransactorRaw) 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 NebulaTransactorSession 

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

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

func (*NebulaTransactorSession) Receive 

func (_Nebula *NebulaTransactorSession) Receive() (*types.Transaction, error)

Receive is a paid mutator transaction binding the contract receive function.

Solidity: receive() payable returns()

func (*NebulaTransactorSession) SendHashValue 

func (_Nebula *NebulaTransactorSession) SendHashValue(dataHash [32]byte, v []uint8, r [][32]byte, s [][32]byte) (*types.Transaction, error)

SendHashValue is a paid mutator transaction binding the contract method 0xbf2c0c42.

Solidity: function sendHashValue(bytes32 dataHash, uint8[] v, bytes32[] r, bytes32[] s) returns()

func (*NebulaTransactorSession) SendValueToSubByte 

func (_Nebula *NebulaTransactorSession) SendValueToSubByte(value []byte, pulseId *big.Int, subId [32]byte) (*types.Transaction, error)

SendValueToSubByte is a paid mutator transaction binding the contract method 0xac557141.

Solidity: function sendValueToSubByte(bytes value, uint256 pulseId, bytes32 subId) returns()

func (*NebulaTransactorSession) SendValueToSubInt 

func (_Nebula *NebulaTransactorSession) SendValueToSubInt(value int64, pulseId *big.Int, subId [32]byte) (*types.Transaction, error)

SendValueToSubInt is a paid mutator transaction binding the contract method 0xff51063b.

Solidity: function sendValueToSubInt(int64 value, uint256 pulseId, bytes32 subId) returns()

func (*NebulaTransactorSession) SendValueToSubString 

func (_Nebula *NebulaTransactorSession) SendValueToSubString(value string, pulseId *big.Int, subId [32]byte) (*types.Transaction, error)

SendValueToSubString is a paid mutator transaction binding the contract method 0x9f95e525.

Solidity: function sendValueToSubString(string value, uint256 pulseId, bytes32 subId) returns()

func (*NebulaTransactorSession) Subscribe 

func (_Nebula *NebulaTransactorSession) Subscribe(contractAddress common.Address, minConfirmations uint8, reward *big.Int) (*types.Transaction, error)

Subscribe is a paid mutator transaction binding the contract method 0x3527715d.

Solidity: function subscribe(address contractAddress, uint8 minConfirmations, uint256 reward) returns()

func (*NebulaTransactorSession) UpdateOracles 

func (_Nebula *NebulaTransactorSession) UpdateOracles(newOracles []common.Address, v []uint8, r [][32]byte, s [][32]byte, newRound *big.Int) (*types.Transaction, error)

UpdateOracles is a paid mutator transaction binding the contract method 0xfebae9ea.

Solidity: function updateOracles(address[] newOracles, uint8[] v, bytes32[] r, bytes32[] s, uint256 newRound) returns()

type QueueLib 

type QueueLib struct {
	QueueLibCaller     // Read-only binding to the contract
	QueueLibTransactor // Write-only binding to the contract
	QueueLibFilterer   // Log filterer for contract events
}

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

func DeployQueueLib 

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

DeployQueueLib deploys a new Ethereum contract, binding an instance of QueueLib to it.

func NewQueueLib 

func NewQueueLib(address common.Address, backend bind.ContractBackend) (*QueueLib, error)

NewQueueLib creates a new instance of QueueLib, bound to a specific deployed contract.

type QueueLibCaller 

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

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

func NewQueueLibCaller 

func NewQueueLibCaller(address common.Address, caller bind.ContractCaller) (*QueueLibCaller, error)

NewQueueLibCaller creates a new read-only instance of QueueLib, bound to a specific deployed contract.

type QueueLibCallerRaw 

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

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

func (*QueueLibCallerRaw) Call 

func (_QueueLib *QueueLibCallerRaw) 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 QueueLibCallerSession 

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

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

type QueueLibFilterer 

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

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

func NewQueueLibFilterer 

func NewQueueLibFilterer(address common.Address, filterer bind.ContractFilterer) (*QueueLibFilterer, error)

NewQueueLibFilterer creates a new log filterer instance of QueueLib, bound to a specific deployed contract.

type QueueLibRaw 

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

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

func (*QueueLibRaw) Call 

func (_QueueLib *QueueLibRaw) 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 (*QueueLibRaw) Transact 

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

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

func (*QueueLibRaw) Transfer 

func (_QueueLib *QueueLibRaw) 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 QueueLibSession 

type QueueLibSession struct {
	Contract     *QueueLib         // 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
}

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

type QueueLibTransactor 

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

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

func NewQueueLibTransactor 

func NewQueueLibTransactor(address common.Address, transactor bind.ContractTransactor) (*QueueLibTransactor, error)

NewQueueLibTransactor creates a new write-only instance of QueueLib, bound to a specific deployed contract.

type QueueLibTransactorRaw 

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

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

func (*QueueLibTransactorRaw) Transact 

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

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

func (*QueueLibTransactorRaw) Transfer 

func (_QueueLib *QueueLibTransactorRaw) 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 QueueLibTransactorSession 

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

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

Source Files

View all Source files

Directories

Path Synopsis
tests
waves

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.