contracts1

package
v0.1.1-0...-94ed833 Latest Latest
Warning

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

 Go to latest Published: Sep 8, 2020 License: MIT Imports: 8 Imported by: 3

Documentation

Index

Constants

View Source 
const SafeMathABI = "[]"

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

View Source 
const SafeMathBin = `` /* 242-byte string literal not displayed */

SafeMathBin is the compiled bytecode used for deploying new contracts.

View Source 
const TellorABI = "" /* 3525-byte string literal not displayed */

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

View Source 
const TellorBin = `` /* 6232-byte string literal not displayed */

TellorBin is the compiled bytecode used for deploying new contracts.

View Source 
const TellorDisputeABI = "" /* 1148-byte string literal not displayed */

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

View Source 
const TellorDisputeBin = `` /* 11314-byte string literal not displayed */

TellorDisputeBin is the compiled bytecode used for deploying new contracts.

View Source 
const TellorGettersLibraryABI = "" /* 150-byte string literal not displayed */

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

View Source 
const TellorGettersLibraryBin = `` /* 242-byte string literal not displayed */

TellorGettersLibraryBin is the compiled bytecode used for deploying new contracts.

View Source 
const TellorLibraryABI = "" /* 2636-byte string literal not displayed */

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

View Source 
const TellorLibraryBin = `` /* 20006-byte string literal not displayed */

TellorLibraryBin is the compiled bytecode used for deploying new contracts.

View Source 
const TellorStakeABI = "" /* 432-byte string literal not displayed */

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

View Source 
const TellorStakeBin = `` /* 4564-byte string literal not displayed */

TellorStakeBin is the compiled bytecode used for deploying new contracts.

View Source 
const TellorStorageABI = "[]"

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

View Source 
const TellorStorageBin = `` /* 242-byte string literal not displayed */

TellorStorageBin is the compiled bytecode used for deploying new contracts.

View Source 
const TellorTransferABI = "" /* 513-byte string literal not displayed */

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

View Source 
const TellorTransferBin = `` /* 4794-byte string literal not displayed */

TellorTransferBin is the compiled bytecode used for deploying new contracts.

View Source 
const UtilitiesABI = "[]"

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

View Source 
const UtilitiesBin = `` /* 242-byte string literal not displayed */

UtilitiesBin is the compiled bytecode used for deploying new contracts.

Variables

This section is empty.

Functions

This section is empty.

Types

type SafeMath 

type SafeMath struct {
	SafeMathCaller     // Read-only binding to the contract
	SafeMathTransactor // Write-only binding to the contract
	SafeMathFilterer   // Log filterer for contract events
}

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

func DeploySafeMath 

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

DeploySafeMath deploys a new Ethereum contract, binding an instance of SafeMath to it.

func NewSafeMath 

func NewSafeMath(address common.Address, backend bind.ContractBackend) (*SafeMath, error)

NewSafeMath creates a new instance of SafeMath, bound to a specific deployed contract.

type SafeMathCaller 

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

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

func NewSafeMathCaller 

func NewSafeMathCaller(address common.Address, caller bind.ContractCaller) (*SafeMathCaller, error)

NewSafeMathCaller creates a new read-only instance of SafeMath, bound to a specific deployed contract.

type SafeMathCallerRaw 

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

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

func (*SafeMathCallerRaw) Call 

func (_SafeMath *SafeMathCallerRaw) 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 SafeMathCallerSession 

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

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

type SafeMathFilterer 

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

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

func NewSafeMathFilterer 

func NewSafeMathFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeMathFilterer, error)

NewSafeMathFilterer creates a new log filterer instance of SafeMath, bound to a specific deployed contract.

type SafeMathRaw 

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

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

func (*SafeMathRaw) Call 

func (_SafeMath *SafeMathRaw) 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 (*SafeMathRaw) Transact 

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

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

func (*SafeMathRaw) Transfer 

func (_SafeMath *SafeMathRaw) 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 SafeMathSession 

type SafeMathSession struct {
	Contract     *SafeMath         // 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
}

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

type SafeMathTransactor 

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

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

func NewSafeMathTransactor 

func NewSafeMathTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeMathTransactor, error)

NewSafeMathTransactor creates a new write-only instance of SafeMath, bound to a specific deployed contract.

type SafeMathTransactorRaw 

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

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

func (*SafeMathTransactorRaw) Transact 

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

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

func (*SafeMathTransactorRaw) Transfer 

func (_SafeMath *SafeMathTransactorRaw) 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 SafeMathTransactorSession 

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

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

type Tellor 

type Tellor struct {
	TellorCaller     // Read-only binding to the contract
	TellorTransactor // Write-only binding to the contract
	TellorFilterer   // Log filterer for contract events
}

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

func DeployTellor 

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

DeployTellor deploys a new Ethereum contract, binding an instance of Tellor to it.

func NewTellor 

func NewTellor(address common.Address, backend bind.ContractBackend) (*Tellor, error)

NewTellor creates a new instance of Tellor, bound to a specific deployed contract.

type TellorCaller 

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

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

func NewTellorCaller 

func NewTellorCaller(address common.Address, caller bind.ContractCaller) (*TellorCaller, error)

NewTellorCaller creates a new read-only instance of Tellor, bound to a specific deployed contract.

type TellorCallerRaw 

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

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

func (*TellorCallerRaw) Call 

func (_Tellor *TellorCallerRaw) 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 TellorCallerSession 

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

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

type TellorDispute 

type TellorDispute struct {
	TellorDisputeCaller     // Read-only binding to the contract
	TellorDisputeTransactor // Write-only binding to the contract
	TellorDisputeFilterer   // Log filterer for contract events
}

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

func DeployTellorDispute 

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

DeployTellorDispute deploys a new Ethereum contract, binding an instance of TellorDispute to it.

func NewTellorDispute 

func NewTellorDispute(address common.Address, backend bind.ContractBackend) (*TellorDispute, error)

NewTellorDispute creates a new instance of TellorDispute, bound to a specific deployed contract.

type TellorDisputeCaller 

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

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

func NewTellorDisputeCaller 

func NewTellorDisputeCaller(address common.Address, caller bind.ContractCaller) (*TellorDisputeCaller, error)

NewTellorDisputeCaller creates a new read-only instance of TellorDispute, bound to a specific deployed contract.

type TellorDisputeCallerRaw 

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

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

func (*TellorDisputeCallerRaw) Call 

func (_TellorDispute *TellorDisputeCallerRaw) 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 TellorDisputeCallerSession 

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

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

type TellorDisputeDisputeVoteTallied 

type TellorDisputeDisputeVoteTallied struct {
	DisputeID      *big.Int
	Result         *big.Int
	ReportedMiner  common.Address
	ReportingParty common.Address
	Active         bool
	Raw            types.Log // Blockchain specific contextual infos
}

TellorDisputeDisputeVoteTallied represents a DisputeVoteTallied event raised by the TellorDispute contract.

type TellorDisputeDisputeVoteTalliedIterator 

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

TellorDisputeDisputeVoteTalliedIterator is returned from FilterDisputeVoteTallied and is used to iterate over the raw logs and unpacked data for DisputeVoteTallied events raised by the TellorDispute contract.

func (*TellorDisputeDisputeVoteTalliedIterator) Close 

func (it *TellorDisputeDisputeVoteTalliedIterator) Close() error

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

func (*TellorDisputeDisputeVoteTalliedIterator) Error 

func (it *TellorDisputeDisputeVoteTalliedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TellorDisputeDisputeVoteTalliedIterator) Next 

func (it *TellorDisputeDisputeVoteTalliedIterator) 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 TellorDisputeFilterer 

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

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

func NewTellorDisputeFilterer 

func NewTellorDisputeFilterer(address common.Address, filterer bind.ContractFilterer) (*TellorDisputeFilterer, error)

NewTellorDisputeFilterer creates a new log filterer instance of TellorDispute, bound to a specific deployed contract.

func (*TellorDisputeFilterer) FilterDisputeVoteTallied 

func (_TellorDispute *TellorDisputeFilterer) FilterDisputeVoteTallied(opts *bind.FilterOpts, _disputeID []*big.Int, _reportedMiner []common.Address) (*TellorDisputeDisputeVoteTalliedIterator, error)

FilterDisputeVoteTallied is a free log retrieval operation binding the contract event 0x21459c2f5447ebcf83a7f0a238c32c71076faef0d12295e771c0cb1e10434739.

Solidity: e DisputeVoteTallied(_disputeID indexed uint256, _result int256, _reportedMiner indexed address, _reportingParty address, _active bool)

func (*TellorDisputeFilterer) FilterNewDispute 

func (_TellorDispute *TellorDisputeFilterer) FilterNewDispute(opts *bind.FilterOpts, _disputeId []*big.Int, _requestId []*big.Int) (*TellorDisputeNewDisputeIterator, error)

FilterNewDispute is a free log retrieval operation binding the contract event 0xeceec1aebf67772b2440120c4b4dc913a1fe1b865509219f9456785c23b9da64.

Solidity: e NewDispute(_disputeId indexed uint256, _requestId indexed uint256, _timestamp uint256, _miner address)

func (*TellorDisputeFilterer) FilterNewTellorAddress 

func (_TellorDispute *TellorDisputeFilterer) FilterNewTellorAddress(opts *bind.FilterOpts) (*TellorDisputeNewTellorAddressIterator, error)

FilterNewTellorAddress is a free log retrieval operation binding the contract event 0xc2d1449eb0b6547aa426e09d9942a77fa4fc8cd3296305b3163e22452e0bcb8d.

Solidity: e NewTellorAddress(_newTellor address)

func (*TellorDisputeFilterer) FilterVoted 

func (_TellorDispute *TellorDisputeFilterer) FilterVoted(opts *bind.FilterOpts, _disputeID []*big.Int, _voter []common.Address) (*TellorDisputeVotedIterator, error)

FilterVoted is a free log retrieval operation binding the contract event 0x86abfce99b7dd908bec0169288797f85049ec73cbe046ed9de818fab3a497ae0.

Solidity: e Voted(_disputeID indexed uint256, _position bool, _voter indexed address)

func (*TellorDisputeFilterer) WatchDisputeVoteTallied 

func (_TellorDispute *TellorDisputeFilterer) WatchDisputeVoteTallied(opts *bind.WatchOpts, sink chan<- *TellorDisputeDisputeVoteTallied, _disputeID []*big.Int, _reportedMiner []common.Address) (event.Subscription, error)

WatchDisputeVoteTallied is a free log subscription operation binding the contract event 0x21459c2f5447ebcf83a7f0a238c32c71076faef0d12295e771c0cb1e10434739.

Solidity: e DisputeVoteTallied(_disputeID indexed uint256, _result int256, _reportedMiner indexed address, _reportingParty address, _active bool)

func (*TellorDisputeFilterer) WatchNewDispute 

func (_TellorDispute *TellorDisputeFilterer) WatchNewDispute(opts *bind.WatchOpts, sink chan<- *TellorDisputeNewDispute, _disputeId []*big.Int, _requestId []*big.Int) (event.Subscription, error)

WatchNewDispute is a free log subscription operation binding the contract event 0xeceec1aebf67772b2440120c4b4dc913a1fe1b865509219f9456785c23b9da64.

Solidity: e NewDispute(_disputeId indexed uint256, _requestId indexed uint256, _timestamp uint256, _miner address)

func (*TellorDisputeFilterer) WatchNewTellorAddress 

func (_TellorDispute *TellorDisputeFilterer) WatchNewTellorAddress(opts *bind.WatchOpts, sink chan<- *TellorDisputeNewTellorAddress) (event.Subscription, error)

WatchNewTellorAddress is a free log subscription operation binding the contract event 0xc2d1449eb0b6547aa426e09d9942a77fa4fc8cd3296305b3163e22452e0bcb8d.

Solidity: e NewTellorAddress(_newTellor address)

func (*TellorDisputeFilterer) WatchVoted 

func (_TellorDispute *TellorDisputeFilterer) WatchVoted(opts *bind.WatchOpts, sink chan<- *TellorDisputeVoted, _disputeID []*big.Int, _voter []common.Address) (event.Subscription, error)

WatchVoted is a free log subscription operation binding the contract event 0x86abfce99b7dd908bec0169288797f85049ec73cbe046ed9de818fab3a497ae0.

Solidity: e Voted(_disputeID indexed uint256, _position bool, _voter indexed address)

type TellorDisputeNewDispute 

type TellorDisputeNewDispute struct {
	DisputeId *big.Int
	RequestId *big.Int
	Timestamp *big.Int
	Miner     common.Address
	Raw       types.Log // Blockchain specific contextual infos
}

TellorDisputeNewDispute represents a NewDispute event raised by the TellorDispute contract.

type TellorDisputeNewDisputeIterator 

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

TellorDisputeNewDisputeIterator is returned from FilterNewDispute and is used to iterate over the raw logs and unpacked data for NewDispute events raised by the TellorDispute contract.

func (*TellorDisputeNewDisputeIterator) Close 

func (it *TellorDisputeNewDisputeIterator) Close() error

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

func (*TellorDisputeNewDisputeIterator) Error 

func (it *TellorDisputeNewDisputeIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TellorDisputeNewDisputeIterator) Next 

func (it *TellorDisputeNewDisputeIterator) 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 TellorDisputeNewTellorAddress 

type TellorDisputeNewTellorAddress struct {
	NewTellor common.Address
	Raw       types.Log // Blockchain specific contextual infos
}

TellorDisputeNewTellorAddress represents a NewTellorAddress event raised by the TellorDispute contract.

type TellorDisputeNewTellorAddressIterator 

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

TellorDisputeNewTellorAddressIterator is returned from FilterNewTellorAddress and is used to iterate over the raw logs and unpacked data for NewTellorAddress events raised by the TellorDispute contract.

func (*TellorDisputeNewTellorAddressIterator) Close 

func (it *TellorDisputeNewTellorAddressIterator) Close() error

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

func (*TellorDisputeNewTellorAddressIterator) Error 

func (it *TellorDisputeNewTellorAddressIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TellorDisputeNewTellorAddressIterator) Next 

func (it *TellorDisputeNewTellorAddressIterator) 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 TellorDisputeRaw 

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

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

func (*TellorDisputeRaw) Call 

func (_TellorDispute *TellorDisputeRaw) 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 (*TellorDisputeRaw) Transact 

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

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

func (*TellorDisputeRaw) Transfer 

func (_TellorDispute *TellorDisputeRaw) 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 TellorDisputeSession 

type TellorDisputeSession struct {
	Contract     *TellorDispute    // 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
}

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

type TellorDisputeTransactor 

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

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

func NewTellorDisputeTransactor 

func NewTellorDisputeTransactor(address common.Address, transactor bind.ContractTransactor) (*TellorDisputeTransactor, error)

NewTellorDisputeTransactor creates a new write-only instance of TellorDispute, bound to a specific deployed contract.

type TellorDisputeTransactorRaw 

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

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

func (*TellorDisputeTransactorRaw) Transact 

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

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

func (*TellorDisputeTransactorRaw) Transfer 

func (_TellorDispute *TellorDisputeTransactorRaw) 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 TellorDisputeTransactorSession 

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

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

type TellorDisputeVoted 

type TellorDisputeVoted struct {
	DisputeID *big.Int
	Position  bool
	Voter     common.Address
	Raw       types.Log // Blockchain specific contextual infos
}

TellorDisputeVoted represents a Voted event raised by the TellorDispute contract.

type TellorDisputeVotedIterator 

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

TellorDisputeVotedIterator is returned from FilterVoted and is used to iterate over the raw logs and unpacked data for Voted events raised by the TellorDispute contract.

func (*TellorDisputeVotedIterator) Close 

func (it *TellorDisputeVotedIterator) Close() error

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

func (*TellorDisputeVotedIterator) Error 

func (it *TellorDisputeVotedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TellorDisputeVotedIterator) Next 

func (it *TellorDisputeVotedIterator) 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 TellorFilterer 

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

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

func NewTellorFilterer 

func NewTellorFilterer(address common.Address, filterer bind.ContractFilterer) (*TellorFilterer, error)

NewTellorFilterer creates a new log filterer instance of Tellor, bound to a specific deployed contract.

type TellorGettersLibrary 

type TellorGettersLibrary struct {
	TellorGettersLibraryCaller     // Read-only binding to the contract
	TellorGettersLibraryTransactor // Write-only binding to the contract
	TellorGettersLibraryFilterer   // Log filterer for contract events
}

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

func DeployTellorGettersLibrary 

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

DeployTellorGettersLibrary deploys a new Ethereum contract, binding an instance of TellorGettersLibrary to it.

func NewTellorGettersLibrary 

func NewTellorGettersLibrary(address common.Address, backend bind.ContractBackend) (*TellorGettersLibrary, error)

NewTellorGettersLibrary creates a new instance of TellorGettersLibrary, bound to a specific deployed contract.

type TellorGettersLibraryCaller 

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

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

func NewTellorGettersLibraryCaller 

func NewTellorGettersLibraryCaller(address common.Address, caller bind.ContractCaller) (*TellorGettersLibraryCaller, error)

NewTellorGettersLibraryCaller creates a new read-only instance of TellorGettersLibrary, bound to a specific deployed contract.

type TellorGettersLibraryCallerRaw 

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

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

func (*TellorGettersLibraryCallerRaw) Call 

func (_TellorGettersLibrary *TellorGettersLibraryCallerRaw) 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 TellorGettersLibraryCallerSession 

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

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

type TellorGettersLibraryFilterer 

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

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

func NewTellorGettersLibraryFilterer 

func NewTellorGettersLibraryFilterer(address common.Address, filterer bind.ContractFilterer) (*TellorGettersLibraryFilterer, error)

NewTellorGettersLibraryFilterer creates a new log filterer instance of TellorGettersLibrary, bound to a specific deployed contract.

func (*TellorGettersLibraryFilterer) FilterNewTellorAddress 

func (_TellorGettersLibrary *TellorGettersLibraryFilterer) FilterNewTellorAddress(opts *bind.FilterOpts) (*TellorGettersLibraryNewTellorAddressIterator, error)

FilterNewTellorAddress is a free log retrieval operation binding the contract event 0xc2d1449eb0b6547aa426e09d9942a77fa4fc8cd3296305b3163e22452e0bcb8d.

Solidity: e NewTellorAddress(_newTellor address)

func (*TellorGettersLibraryFilterer) WatchNewTellorAddress 

func (_TellorGettersLibrary *TellorGettersLibraryFilterer) WatchNewTellorAddress(opts *bind.WatchOpts, sink chan<- *TellorGettersLibraryNewTellorAddress) (event.Subscription, error)

WatchNewTellorAddress is a free log subscription operation binding the contract event 0xc2d1449eb0b6547aa426e09d9942a77fa4fc8cd3296305b3163e22452e0bcb8d.

Solidity: e NewTellorAddress(_newTellor address)

type TellorGettersLibraryNewTellorAddress 

type TellorGettersLibraryNewTellorAddress struct {
	NewTellor common.Address
	Raw       types.Log // Blockchain specific contextual infos
}

TellorGettersLibraryNewTellorAddress represents a NewTellorAddress event raised by the TellorGettersLibrary contract.

type TellorGettersLibraryNewTellorAddressIterator 

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

TellorGettersLibraryNewTellorAddressIterator is returned from FilterNewTellorAddress and is used to iterate over the raw logs and unpacked data for NewTellorAddress events raised by the TellorGettersLibrary contract.

func (*TellorGettersLibraryNewTellorAddressIterator) Close 

func (it *TellorGettersLibraryNewTellorAddressIterator) Close() error

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

func (*TellorGettersLibraryNewTellorAddressIterator) Error 

func (it *TellorGettersLibraryNewTellorAddressIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TellorGettersLibraryNewTellorAddressIterator) Next 

func (it *TellorGettersLibraryNewTellorAddressIterator) 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 TellorGettersLibraryRaw 

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

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

func (*TellorGettersLibraryRaw) Call 

func (_TellorGettersLibrary *TellorGettersLibraryRaw) 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 (*TellorGettersLibraryRaw) Transact 

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

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

func (*TellorGettersLibraryRaw) Transfer 

func (_TellorGettersLibrary *TellorGettersLibraryRaw) 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 TellorGettersLibrarySession 

type TellorGettersLibrarySession struct {
	Contract     *TellorGettersLibrary // 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
}

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

type TellorGettersLibraryTransactor 

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

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

func NewTellorGettersLibraryTransactor 

func NewTellorGettersLibraryTransactor(address common.Address, transactor bind.ContractTransactor) (*TellorGettersLibraryTransactor, error)

NewTellorGettersLibraryTransactor creates a new write-only instance of TellorGettersLibrary, bound to a specific deployed contract.

type TellorGettersLibraryTransactorRaw 

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

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

func (*TellorGettersLibraryTransactorRaw) Transact 

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

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

func (*TellorGettersLibraryTransactorRaw) Transfer 

func (_TellorGettersLibrary *TellorGettersLibraryTransactorRaw) 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 TellorGettersLibraryTransactorSession 

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

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

type TellorLibrary 

type TellorLibrary struct {
	TellorLibraryCaller     // Read-only binding to the contract
	TellorLibraryTransactor // Write-only binding to the contract
	TellorLibraryFilterer   // Log filterer for contract events
}

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

func DeployTellorLibrary 

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

DeployTellorLibrary deploys a new Ethereum contract, binding an instance of TellorLibrary to it.

func NewTellorLibrary 

func NewTellorLibrary(address common.Address, backend bind.ContractBackend) (*TellorLibrary, error)

NewTellorLibrary creates a new instance of TellorLibrary, bound to a specific deployed contract.

type TellorLibraryCaller 

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

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

func NewTellorLibraryCaller 

func NewTellorLibraryCaller(address common.Address, caller bind.ContractCaller) (*TellorLibraryCaller, error)

NewTellorLibraryCaller creates a new read-only instance of TellorLibrary, bound to a specific deployed contract.

type TellorLibraryCallerRaw 

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

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

func (*TellorLibraryCallerRaw) Call 

func (_TellorLibrary *TellorLibraryCallerRaw) 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 TellorLibraryCallerSession 

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

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

type TellorLibraryDataRequested 

type TellorLibraryDataRequested struct {
	Sender      common.Address
	Query       string
	QuerySymbol string
	Granularity *big.Int
	RequestId   *big.Int
	TotalTips   *big.Int
	Raw         types.Log // Blockchain specific contextual infos
}

TellorLibraryDataRequested represents a DataRequested event raised by the TellorLibrary contract.

type TellorLibraryDataRequestedIterator 

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

TellorLibraryDataRequestedIterator is returned from FilterDataRequested and is used to iterate over the raw logs and unpacked data for DataRequested events raised by the TellorLibrary contract.

func (*TellorLibraryDataRequestedIterator) Close 

func (it *TellorLibraryDataRequestedIterator) Close() error

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

func (*TellorLibraryDataRequestedIterator) Error 

func (it *TellorLibraryDataRequestedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TellorLibraryDataRequestedIterator) Next 

func (it *TellorLibraryDataRequestedIterator) 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 TellorLibraryFilterer 

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

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

func NewTellorLibraryFilterer 

func NewTellorLibraryFilterer(address common.Address, filterer bind.ContractFilterer) (*TellorLibraryFilterer, error)

NewTellorLibraryFilterer creates a new log filterer instance of TellorLibrary, bound to a specific deployed contract.

func (*TellorLibraryFilterer) FilterDataRequested 

func (_TellorLibrary *TellorLibraryFilterer) FilterDataRequested(opts *bind.FilterOpts, _sender []common.Address, _requestId []*big.Int) (*TellorLibraryDataRequestedIterator, error)

FilterDataRequested is a free log retrieval operation binding the contract event 0x6d7f869757848b19c8c2456e95cd98885bc6bed062fda4077bb07985e2f76cc9.

Solidity: e DataRequested(_sender indexed address, _query string, _querySymbol string, _granularity uint256, _requestId indexed uint256, _totalTips uint256)

func (*TellorLibraryFilterer) FilterNewChallenge 

func (_TellorLibrary *TellorLibraryFilterer) FilterNewChallenge(opts *bind.FilterOpts, _currentRequestId []*big.Int) (*TellorLibraryNewChallengeIterator, error)

FilterNewChallenge is a free log retrieval operation binding the contract event 0x9e959738f09af22daede9ff9563f8edf3f5cec8e17ce60287c911c95fa767f42.

Solidity: e NewChallenge(_currentChallenge bytes32, _currentRequestId indexed uint256, _difficulty uint256, _multiplier uint256, _query string, _totalTips uint256)

func (*TellorLibraryFilterer) FilterNewRequestOnDeck 

func (_TellorLibrary *TellorLibraryFilterer) FilterNewRequestOnDeck(opts *bind.FilterOpts, _requestId []*big.Int) (*TellorLibraryNewRequestOnDeckIterator, error)

FilterNewRequestOnDeck is a free log retrieval operation binding the contract event 0x5ab383fe3e28263c839564bc7545520a7dd34b78cbd7ab21b2da5d2fd027bf6c.

Solidity: e NewRequestOnDeck(_requestId indexed uint256, _query string, _onDeckQueryHash bytes32, _onDeckTotalTips uint256)

func (*TellorLibraryFilterer) FilterNewValue 

func (_TellorLibrary *TellorLibraryFilterer) FilterNewValue(opts *bind.FilterOpts, _requestId []*big.Int) (*TellorLibraryNewValueIterator, error)

FilterNewValue is a free log retrieval operation binding the contract event 0xc509d04e0782579ee59912139246ccbdf6c36c43abd90591d912017f3467dd16.

Solidity: e NewValue(_requestId indexed uint256, _time uint256, _value uint256, _totalTips uint256, _currentChallenge bytes32)

func (*TellorLibraryFilterer) FilterNonceSubmitted 

func (_TellorLibrary *TellorLibraryFilterer) FilterNonceSubmitted(opts *bind.FilterOpts, _miner []common.Address, _requestId []*big.Int) (*TellorLibraryNonceSubmittedIterator, error)

FilterNonceSubmitted is a free log retrieval operation binding the contract event 0xe6d63a2aee0aaed2ab49702313ce54114f2145af219d7db30d6624af9e6dffc4.

Solidity: e NonceSubmitted(_miner indexed address, _nonce string, _requestId indexed uint256, _value uint256, _currentChallenge bytes32)

func (*TellorLibraryFilterer) FilterOwnershipTransferred 

func (_TellorLibrary *TellorLibraryFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, _previousOwner []common.Address, _newOwner []common.Address) (*TellorLibraryOwnershipTransferredIterator, error)

FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: e OwnershipTransferred(_previousOwner indexed address, _newOwner indexed address)

func (*TellorLibraryFilterer) FilterTipAdded 

func (_TellorLibrary *TellorLibraryFilterer) FilterTipAdded(opts *bind.FilterOpts, _sender []common.Address, _requestId []*big.Int) (*TellorLibraryTipAddedIterator, error)

FilterTipAdded is a free log retrieval operation binding the contract event 0xd32134405b68f6f7220f9c38ae310df1b648d16188006768d45be2f7c24e8820.

Solidity: e TipAdded(_sender indexed address, _requestId indexed uint256, _tip uint256, _totalTips uint256)

func (*TellorLibraryFilterer) WatchDataRequested 

func (_TellorLibrary *TellorLibraryFilterer) WatchDataRequested(opts *bind.WatchOpts, sink chan<- *TellorLibraryDataRequested, _sender []common.Address, _requestId []*big.Int) (event.Subscription, error)

WatchDataRequested is a free log subscription operation binding the contract event 0x6d7f869757848b19c8c2456e95cd98885bc6bed062fda4077bb07985e2f76cc9.

Solidity: e DataRequested(_sender indexed address, _query string, _querySymbol string, _granularity uint256, _requestId indexed uint256, _totalTips uint256)

func (*TellorLibraryFilterer) WatchNewChallenge 

func (_TellorLibrary *TellorLibraryFilterer) WatchNewChallenge(opts *bind.WatchOpts, sink chan<- *TellorLibraryNewChallenge, _currentRequestId []*big.Int) (event.Subscription, error)

WatchNewChallenge is a free log subscription operation binding the contract event 0x9e959738f09af22daede9ff9563f8edf3f5cec8e17ce60287c911c95fa767f42.

Solidity: e NewChallenge(_currentChallenge bytes32, _currentRequestId indexed uint256, _difficulty uint256, _multiplier uint256, _query string, _totalTips uint256)

func (*TellorLibraryFilterer) WatchNewRequestOnDeck 

func (_TellorLibrary *TellorLibraryFilterer) WatchNewRequestOnDeck(opts *bind.WatchOpts, sink chan<- *TellorLibraryNewRequestOnDeck, _requestId []*big.Int) (event.Subscription, error)

WatchNewRequestOnDeck is a free log subscription operation binding the contract event 0x5ab383fe3e28263c839564bc7545520a7dd34b78cbd7ab21b2da5d2fd027bf6c.

Solidity: e NewRequestOnDeck(_requestId indexed uint256, _query string, _onDeckQueryHash bytes32, _onDeckTotalTips uint256)

func (*TellorLibraryFilterer) WatchNewValue 

func (_TellorLibrary *TellorLibraryFilterer) WatchNewValue(opts *bind.WatchOpts, sink chan<- *TellorLibraryNewValue, _requestId []*big.Int) (event.Subscription, error)

WatchNewValue is a free log subscription operation binding the contract event 0xc509d04e0782579ee59912139246ccbdf6c36c43abd90591d912017f3467dd16.

Solidity: e NewValue(_requestId indexed uint256, _time uint256, _value uint256, _totalTips uint256, _currentChallenge bytes32)

func (*TellorLibraryFilterer) WatchNonceSubmitted 

func (_TellorLibrary *TellorLibraryFilterer) WatchNonceSubmitted(opts *bind.WatchOpts, sink chan<- *TellorLibraryNonceSubmitted, _miner []common.Address, _requestId []*big.Int) (event.Subscription, error)

WatchNonceSubmitted is a free log subscription operation binding the contract event 0xe6d63a2aee0aaed2ab49702313ce54114f2145af219d7db30d6624af9e6dffc4.

Solidity: e NonceSubmitted(_miner indexed address, _nonce string, _requestId indexed uint256, _value uint256, _currentChallenge bytes32)

func (*TellorLibraryFilterer) WatchOwnershipTransferred 

func (_TellorLibrary *TellorLibraryFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *TellorLibraryOwnershipTransferred, _previousOwner []common.Address, _newOwner []common.Address) (event.Subscription, error)

WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.

Solidity: e OwnershipTransferred(_previousOwner indexed address, _newOwner indexed address)

func (*TellorLibraryFilterer) WatchTipAdded 

func (_TellorLibrary *TellorLibraryFilterer) WatchTipAdded(opts *bind.WatchOpts, sink chan<- *TellorLibraryTipAdded, _sender []common.Address, _requestId []*big.Int) (event.Subscription, error)

WatchTipAdded is a free log subscription operation binding the contract event 0xd32134405b68f6f7220f9c38ae310df1b648d16188006768d45be2f7c24e8820.

Solidity: e TipAdded(_sender indexed address, _requestId indexed uint256, _tip uint256, _totalTips uint256)

type TellorLibraryNewChallenge 

type TellorLibraryNewChallenge struct {
	CurrentChallenge [32]byte
	CurrentRequestId *big.Int
	Difficulty       *big.Int
	Multiplier       *big.Int
	Query            string
	TotalTips        *big.Int
	Raw              types.Log // Blockchain specific contextual infos
}

TellorLibraryNewChallenge represents a NewChallenge event raised by the TellorLibrary contract.

type TellorLibraryNewChallengeIterator 

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

TellorLibraryNewChallengeIterator is returned from FilterNewChallenge and is used to iterate over the raw logs and unpacked data for NewChallenge events raised by the TellorLibrary contract.

func (*TellorLibraryNewChallengeIterator) Close 

func (it *TellorLibraryNewChallengeIterator) Close() error

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

func (*TellorLibraryNewChallengeIterator) Error 

func (it *TellorLibraryNewChallengeIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TellorLibraryNewChallengeIterator) Next 

func (it *TellorLibraryNewChallengeIterator) 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 TellorLibraryNewRequestOnDeck 

type TellorLibraryNewRequestOnDeck struct {
	RequestId       *big.Int
	Query           string
	OnDeckQueryHash [32]byte
	OnDeckTotalTips *big.Int
	Raw             types.Log // Blockchain specific contextual infos
}

TellorLibraryNewRequestOnDeck represents a NewRequestOnDeck event raised by the TellorLibrary contract.

type TellorLibraryNewRequestOnDeckIterator 

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

TellorLibraryNewRequestOnDeckIterator is returned from FilterNewRequestOnDeck and is used to iterate over the raw logs and unpacked data for NewRequestOnDeck events raised by the TellorLibrary contract.

func (*TellorLibraryNewRequestOnDeckIterator) Close 

func (it *TellorLibraryNewRequestOnDeckIterator) Close() error

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

func (*TellorLibraryNewRequestOnDeckIterator) Error 

func (it *TellorLibraryNewRequestOnDeckIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TellorLibraryNewRequestOnDeckIterator) Next 

func (it *TellorLibraryNewRequestOnDeckIterator) 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 TellorLibraryNewValue 

type TellorLibraryNewValue struct {
	RequestId        *big.Int
	Time             *big.Int
	Value            *big.Int
	TotalTips        *big.Int
	CurrentChallenge [32]byte
	Raw              types.Log // Blockchain specific contextual infos
}

TellorLibraryNewValue represents a NewValue event raised by the TellorLibrary contract.

type TellorLibraryNewValueIterator 

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

TellorLibraryNewValueIterator is returned from FilterNewValue and is used to iterate over the raw logs and unpacked data for NewValue events raised by the TellorLibrary contract.

func (*TellorLibraryNewValueIterator) Close 

func (it *TellorLibraryNewValueIterator) Close() error

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

func (*TellorLibraryNewValueIterator) Error 

func (it *TellorLibraryNewValueIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TellorLibraryNewValueIterator) Next 

func (it *TellorLibraryNewValueIterator) 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 TellorLibraryNonceSubmitted 

type TellorLibraryNonceSubmitted struct {
	Miner            common.Address
	Nonce            string
	RequestId        *big.Int
	Value            *big.Int
	CurrentChallenge [32]byte
	Raw              types.Log // Blockchain specific contextual infos
}

TellorLibraryNonceSubmitted represents a NonceSubmitted event raised by the TellorLibrary contract.

type TellorLibraryNonceSubmittedIterator 

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

TellorLibraryNonceSubmittedIterator is returned from FilterNonceSubmitted and is used to iterate over the raw logs and unpacked data for NonceSubmitted events raised by the TellorLibrary contract.

func (*TellorLibraryNonceSubmittedIterator) Close 

func (it *TellorLibraryNonceSubmittedIterator) Close() error

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

func (*TellorLibraryNonceSubmittedIterator) Error 

func (it *TellorLibraryNonceSubmittedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TellorLibraryNonceSubmittedIterator) Next 

func (it *TellorLibraryNonceSubmittedIterator) 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 TellorLibraryOwnershipTransferred 

type TellorLibraryOwnershipTransferred struct {
	PreviousOwner common.Address
	NewOwner      common.Address
	Raw           types.Log // Blockchain specific contextual infos
}

TellorLibraryOwnershipTransferred represents a OwnershipTransferred event raised by the TellorLibrary contract.

type TellorLibraryOwnershipTransferredIterator 

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

TellorLibraryOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the TellorLibrary contract.

func (*TellorLibraryOwnershipTransferredIterator) Close 

func (it *TellorLibraryOwnershipTransferredIterator) Close() error

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

func (*TellorLibraryOwnershipTransferredIterator) Error 

func (it *TellorLibraryOwnershipTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TellorLibraryOwnershipTransferredIterator) Next 

func (it *TellorLibraryOwnershipTransferredIterator) 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 TellorLibraryRaw 

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

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

func (*TellorLibraryRaw) Call 

func (_TellorLibrary *TellorLibraryRaw) 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 (*TellorLibraryRaw) Transact 

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

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

func (*TellorLibraryRaw) Transfer 

func (_TellorLibrary *TellorLibraryRaw) 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 TellorLibrarySession 

type TellorLibrarySession struct {
	Contract     *TellorLibrary    // 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
}

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

type TellorLibraryTipAdded 

type TellorLibraryTipAdded struct {
	Sender    common.Address
	RequestId *big.Int
	Tip       *big.Int
	TotalTips *big.Int
	Raw       types.Log // Blockchain specific contextual infos
}

TellorLibraryTipAdded represents a TipAdded event raised by the TellorLibrary contract.

type TellorLibraryTipAddedIterator 

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

TellorLibraryTipAddedIterator is returned from FilterTipAdded and is used to iterate over the raw logs and unpacked data for TipAdded events raised by the TellorLibrary contract.

func (*TellorLibraryTipAddedIterator) Close 

func (it *TellorLibraryTipAddedIterator) Close() error

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

func (*TellorLibraryTipAddedIterator) Error 

func (it *TellorLibraryTipAddedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TellorLibraryTipAddedIterator) Next 

func (it *TellorLibraryTipAddedIterator) 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 TellorLibraryTransactor 

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

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

func NewTellorLibraryTransactor 

func NewTellorLibraryTransactor(address common.Address, transactor bind.ContractTransactor) (*TellorLibraryTransactor, error)

NewTellorLibraryTransactor creates a new write-only instance of TellorLibrary, bound to a specific deployed contract.

type TellorLibraryTransactorRaw 

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

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

func (*TellorLibraryTransactorRaw) Transact 

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

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

func (*TellorLibraryTransactorRaw) Transfer 

func (_TellorLibrary *TellorLibraryTransactorRaw) 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 TellorLibraryTransactorSession 

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

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

type TellorRaw 

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

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

func (*TellorRaw) Call 

func (_Tellor *TellorRaw) 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 (*TellorRaw) Transact 

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

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

func (*TellorRaw) Transfer 

func (_Tellor *TellorRaw) 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 TellorSession 

type TellorSession struct {
	Contract     *Tellor           // 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
}

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

func (*TellorSession) AddTip 

func (_Tellor *TellorSession) AddTip(_requestId *big.Int, _tip *big.Int) (*types.Transaction, error)

AddTip is a paid mutator transaction binding the contract method 0x752d49a1.

Solidity: function addTip(_requestId uint256, _tip uint256) returns()

func (*TellorSession) Approve 

func (_Tellor *TellorSession) Approve(_spender common.Address, _amount *big.Int) (*types.Transaction, error)

Approve is a paid mutator transaction binding the contract method 0x095ea7b3.

Solidity: function approve(_spender address, _amount uint256) returns(bool)

func (*TellorSession) BeginDispute 

func (_Tellor *TellorSession) BeginDispute(_requestId *big.Int, _timestamp *big.Int, _minerIndex *big.Int) (*types.Transaction, error)

BeginDispute is a paid mutator transaction binding the contract method 0x8581af19.

Solidity: function beginDispute(_requestId uint256, _timestamp uint256, _minerIndex uint256) returns()

func (*TellorSession) DepositStake 

func (_Tellor *TellorSession) DepositStake() (*types.Transaction, error)

DepositStake is a paid mutator transaction binding the contract method 0x0d2d76a2.

Solidity: function depositStake() returns()

func (*TellorSession) ProposeFork 

func (_Tellor *TellorSession) ProposeFork(_propNewTellorAddress common.Address) (*types.Transaction, error)

ProposeFork is a paid mutator transaction binding the contract method 0x26b7d9f6.

Solidity: function proposeFork(_propNewTellorAddress address) returns()

func (*TellorSession) RequestData 

func (_Tellor *TellorSession) RequestData(_c_sapi string, _c_symbol string, _granularity *big.Int, _tip *big.Int) (*types.Transaction, error)

RequestData is a paid mutator transaction binding the contract method 0x3fff2816.

Solidity: function requestData(_c_sapi string, _c_symbol string, _granularity uint256, _tip uint256) returns()

func (*TellorSession) RequestStakingWithdraw 

func (_Tellor *TellorSession) RequestStakingWithdraw() (*types.Transaction, error)

RequestStakingWithdraw is a paid mutator transaction binding the contract method 0x28449c3a.

Solidity: function requestStakingWithdraw() returns()

func (*TellorSession) SubmitMiningSolution 

func (_Tellor *TellorSession) SubmitMiningSolution(_nonce string, _requestId *big.Int, _value *big.Int) (*types.Transaction, error)

SubmitMiningSolution is a paid mutator transaction binding the contract method 0x68c180d5.

Solidity: function submitMiningSolution(_nonce string, _requestId uint256, _value uint256) returns()

func (*TellorSession) TallyVotes 

func (_Tellor *TellorSession) TallyVotes(_disputeId *big.Int) (*types.Transaction, error)

TallyVotes is a paid mutator transaction binding the contract method 0x4d318b0e.

Solidity: function tallyVotes(_disputeId uint256) returns()

func (*TellorSession) TheLazyCoon 

func (_Tellor *TellorSession) TheLazyCoon(_address common.Address, _amount *big.Int) (*types.Transaction, error)

TheLazyCoon is a paid mutator transaction binding the contract method 0xb079f64a.

Solidity: function theLazyCoon(_address address, _amount uint256) returns()

func (*TellorSession) Transfer 

func (_Tellor *TellorSession) Transfer(_to common.Address, _amount *big.Int) (*types.Transaction, error)

Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.

Solidity: function transfer(_to address, _amount uint256) returns(bool)

func (*TellorSession) TransferFrom 

func (_Tellor *TellorSession) TransferFrom(_from common.Address, _to common.Address, _amount *big.Int) (*types.Transaction, error)

TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.

Solidity: function transferFrom(_from address, _to address, _amount uint256) returns(bool)

func (*TellorSession) TransferOwnership 

func (_Tellor *TellorSession) TransferOwnership(_newOwner common.Address) (*types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(_newOwner address) returns()

func (*TellorSession) Vote 

func (_Tellor *TellorSession) Vote(_disputeId *big.Int, _supportsDispute bool) (*types.Transaction, error)

Vote is a paid mutator transaction binding the contract method 0xc9d27afe.

Solidity: function vote(_disputeId uint256, _supportsDispute bool) returns()

func (*TellorSession) WithdrawStake 

func (_Tellor *TellorSession) WithdrawStake() (*types.Transaction, error)

WithdrawStake is a paid mutator transaction binding the contract method 0xbed9d861.

Solidity: function withdrawStake() returns()

type TellorStake 

type TellorStake struct {
	TellorStakeCaller     // Read-only binding to the contract
	TellorStakeTransactor // Write-only binding to the contract
	TellorStakeFilterer   // Log filterer for contract events
}

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

func DeployTellorStake 

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

DeployTellorStake deploys a new Ethereum contract, binding an instance of TellorStake to it.

func NewTellorStake 

func NewTellorStake(address common.Address, backend bind.ContractBackend) (*TellorStake, error)

NewTellorStake creates a new instance of TellorStake, bound to a specific deployed contract.

type TellorStakeCaller 

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

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

func NewTellorStakeCaller 

func NewTellorStakeCaller(address common.Address, caller bind.ContractCaller) (*TellorStakeCaller, error)

NewTellorStakeCaller creates a new read-only instance of TellorStake, bound to a specific deployed contract.

type TellorStakeCallerRaw 

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

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

func (*TellorStakeCallerRaw) Call 

func (_TellorStake *TellorStakeCallerRaw) 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 TellorStakeCallerSession 

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

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

type TellorStakeFilterer 

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

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

func NewTellorStakeFilterer 

func NewTellorStakeFilterer(address common.Address, filterer bind.ContractFilterer) (*TellorStakeFilterer, error)

NewTellorStakeFilterer creates a new log filterer instance of TellorStake, bound to a specific deployed contract.

func (*TellorStakeFilterer) FilterNewStake 

func (_TellorStake *TellorStakeFilterer) FilterNewStake(opts *bind.FilterOpts, _sender []common.Address) (*TellorStakeNewStakeIterator, error)

FilterNewStake is a free log retrieval operation binding the contract event 0x46d8ab1385f70e5a3673e97c23c764f7600f7ed7a09b6687deae7131d51752e2.

Solidity: e NewStake(_sender indexed address)

func (*TellorStakeFilterer) FilterStakeWithdrawRequested 

func (_TellorStake *TellorStakeFilterer) FilterStakeWithdrawRequested(opts *bind.FilterOpts, _sender []common.Address) (*TellorStakeStakeWithdrawRequestedIterator, error)

FilterStakeWithdrawRequested is a free log retrieval operation binding the contract event 0x453865710d0cb4b14ad25de371c860da196368895daa9662e5087711d14daecf.

Solidity: e StakeWithdrawRequested(_sender indexed address)

func (*TellorStakeFilterer) FilterStakeWithdrawn 

func (_TellorStake *TellorStakeFilterer) FilterStakeWithdrawn(opts *bind.FilterOpts, _sender []common.Address) (*TellorStakeStakeWithdrawnIterator, error)

FilterStakeWithdrawn is a free log retrieval operation binding the contract event 0x4a7934670bd8304e7da22378be1368f7c4fef17c5aee81804beda8638fe428ec.

Solidity: e StakeWithdrawn(_sender indexed address)

func (*TellorStakeFilterer) WatchNewStake 

func (_TellorStake *TellorStakeFilterer) WatchNewStake(opts *bind.WatchOpts, sink chan<- *TellorStakeNewStake, _sender []common.Address) (event.Subscription, error)

WatchNewStake is a free log subscription operation binding the contract event 0x46d8ab1385f70e5a3673e97c23c764f7600f7ed7a09b6687deae7131d51752e2.

Solidity: e NewStake(_sender indexed address)

func (*TellorStakeFilterer) WatchStakeWithdrawRequested 

func (_TellorStake *TellorStakeFilterer) WatchStakeWithdrawRequested(opts *bind.WatchOpts, sink chan<- *TellorStakeStakeWithdrawRequested, _sender []common.Address) (event.Subscription, error)

WatchStakeWithdrawRequested is a free log subscription operation binding the contract event 0x453865710d0cb4b14ad25de371c860da196368895daa9662e5087711d14daecf.

Solidity: e StakeWithdrawRequested(_sender indexed address)

func (*TellorStakeFilterer) WatchStakeWithdrawn 

func (_TellorStake *TellorStakeFilterer) WatchStakeWithdrawn(opts *bind.WatchOpts, sink chan<- *TellorStakeStakeWithdrawn, _sender []common.Address) (event.Subscription, error)

WatchStakeWithdrawn is a free log subscription operation binding the contract event 0x4a7934670bd8304e7da22378be1368f7c4fef17c5aee81804beda8638fe428ec.

Solidity: e StakeWithdrawn(_sender indexed address)

type TellorStakeNewStake 

type TellorStakeNewStake struct {
	Sender common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

TellorStakeNewStake represents a NewStake event raised by the TellorStake contract.

type TellorStakeNewStakeIterator 

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

TellorStakeNewStakeIterator is returned from FilterNewStake and is used to iterate over the raw logs and unpacked data for NewStake events raised by the TellorStake contract.

func (*TellorStakeNewStakeIterator) Close 

func (it *TellorStakeNewStakeIterator) Close() error

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

func (*TellorStakeNewStakeIterator) Error 

func (it *TellorStakeNewStakeIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TellorStakeNewStakeIterator) Next 

func (it *TellorStakeNewStakeIterator) 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 TellorStakeRaw 

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

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

func (*TellorStakeRaw) Call 

func (_TellorStake *TellorStakeRaw) 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 (*TellorStakeRaw) Transact 

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

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

func (*TellorStakeRaw) Transfer 

func (_TellorStake *TellorStakeRaw) 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 TellorStakeSession 

type TellorStakeSession struct {
	Contract     *TellorStake      // 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
}

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

type TellorStakeStakeWithdrawRequested 

type TellorStakeStakeWithdrawRequested struct {
	Sender common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

TellorStakeStakeWithdrawRequested represents a StakeWithdrawRequested event raised by the TellorStake contract.

type TellorStakeStakeWithdrawRequestedIterator 

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

TellorStakeStakeWithdrawRequestedIterator is returned from FilterStakeWithdrawRequested and is used to iterate over the raw logs and unpacked data for StakeWithdrawRequested events raised by the TellorStake contract.

func (*TellorStakeStakeWithdrawRequestedIterator) Close 

func (it *TellorStakeStakeWithdrawRequestedIterator) Close() error

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

func (*TellorStakeStakeWithdrawRequestedIterator) Error 

func (it *TellorStakeStakeWithdrawRequestedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TellorStakeStakeWithdrawRequestedIterator) Next 

func (it *TellorStakeStakeWithdrawRequestedIterator) 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 TellorStakeStakeWithdrawn 

type TellorStakeStakeWithdrawn struct {
	Sender common.Address
	Raw    types.Log // Blockchain specific contextual infos
}

TellorStakeStakeWithdrawn represents a StakeWithdrawn event raised by the TellorStake contract.

type TellorStakeStakeWithdrawnIterator 

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

TellorStakeStakeWithdrawnIterator is returned from FilterStakeWithdrawn and is used to iterate over the raw logs and unpacked data for StakeWithdrawn events raised by the TellorStake contract.

func (*TellorStakeStakeWithdrawnIterator) Close 

func (it *TellorStakeStakeWithdrawnIterator) Close() error

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

func (*TellorStakeStakeWithdrawnIterator) Error 

func (it *TellorStakeStakeWithdrawnIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TellorStakeStakeWithdrawnIterator) Next 

func (it *TellorStakeStakeWithdrawnIterator) 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 TellorStakeTransactor 

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

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

func NewTellorStakeTransactor 

func NewTellorStakeTransactor(address common.Address, transactor bind.ContractTransactor) (*TellorStakeTransactor, error)

NewTellorStakeTransactor creates a new write-only instance of TellorStake, bound to a specific deployed contract.

type TellorStakeTransactorRaw 

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

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

func (*TellorStakeTransactorRaw) Transact 

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

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

func (*TellorStakeTransactorRaw) Transfer 

func (_TellorStake *TellorStakeTransactorRaw) 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 TellorStakeTransactorSession 

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

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

type TellorStorage 

type TellorStorage struct {
	TellorStorageCaller     // Read-only binding to the contract
	TellorStorageTransactor // Write-only binding to the contract
	TellorStorageFilterer   // Log filterer for contract events
}

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

func DeployTellorStorage 

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

DeployTellorStorage deploys a new Ethereum contract, binding an instance of TellorStorage to it.

func NewTellorStorage 

func NewTellorStorage(address common.Address, backend bind.ContractBackend) (*TellorStorage, error)

NewTellorStorage creates a new instance of TellorStorage, bound to a specific deployed contract.

type TellorStorageCaller 

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

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

func NewTellorStorageCaller 

func NewTellorStorageCaller(address common.Address, caller bind.ContractCaller) (*TellorStorageCaller, error)

NewTellorStorageCaller creates a new read-only instance of TellorStorage, bound to a specific deployed contract.

type TellorStorageCallerRaw 

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

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

func (*TellorStorageCallerRaw) Call 

func (_TellorStorage *TellorStorageCallerRaw) 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 TellorStorageCallerSession 

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

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

type TellorStorageFilterer 

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

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

func NewTellorStorageFilterer 

func NewTellorStorageFilterer(address common.Address, filterer bind.ContractFilterer) (*TellorStorageFilterer, error)

NewTellorStorageFilterer creates a new log filterer instance of TellorStorage, bound to a specific deployed contract.

type TellorStorageRaw 

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

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

func (*TellorStorageRaw) Call 

func (_TellorStorage *TellorStorageRaw) 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 (*TellorStorageRaw) Transact 

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

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

func (*TellorStorageRaw) Transfer 

func (_TellorStorage *TellorStorageRaw) 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 TellorStorageSession 

type TellorStorageSession struct {
	Contract     *TellorStorage    // 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
}

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

type TellorStorageTransactor 

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

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

func NewTellorStorageTransactor 

func NewTellorStorageTransactor(address common.Address, transactor bind.ContractTransactor) (*TellorStorageTransactor, error)

NewTellorStorageTransactor creates a new write-only instance of TellorStorage, bound to a specific deployed contract.

type TellorStorageTransactorRaw 

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

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

func (*TellorStorageTransactorRaw) Transact 

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

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

func (*TellorStorageTransactorRaw) Transfer 

func (_TellorStorage *TellorStorageTransactorRaw) 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 TellorStorageTransactorSession 

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

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

type TellorTransactor 

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

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

func NewTellorTransactor 

func NewTellorTransactor(address common.Address, transactor bind.ContractTransactor) (*TellorTransactor, error)

NewTellorTransactor creates a new write-only instance of Tellor, bound to a specific deployed contract.

func (*TellorTransactor) AddTip 

func (_Tellor *TellorTransactor) AddTip(opts *bind.TransactOpts, _requestId *big.Int, _tip *big.Int) (*types.Transaction, error)

AddTip is a paid mutator transaction binding the contract method 0x752d49a1.

Solidity: function addTip(_requestId uint256, _tip uint256) returns()

func (*TellorTransactor) Approve 

func (_Tellor *TellorTransactor) Approve(opts *bind.TransactOpts, _spender common.Address, _amount *big.Int) (*types.Transaction, error)

Approve is a paid mutator transaction binding the contract method 0x095ea7b3.

Solidity: function approve(_spender address, _amount uint256) returns(bool)

func (*TellorTransactor) BeginDispute 

func (_Tellor *TellorTransactor) BeginDispute(opts *bind.TransactOpts, _requestId *big.Int, _timestamp *big.Int, _minerIndex *big.Int) (*types.Transaction, error)

BeginDispute is a paid mutator transaction binding the contract method 0x8581af19.

Solidity: function beginDispute(_requestId uint256, _timestamp uint256, _minerIndex uint256) returns()

func (*TellorTransactor) DepositStake 

func (_Tellor *TellorTransactor) DepositStake(opts *bind.TransactOpts) (*types.Transaction, error)

DepositStake is a paid mutator transaction binding the contract method 0x0d2d76a2.

Solidity: function depositStake() returns()

func (*TellorTransactor) ProposeFork 

func (_Tellor *TellorTransactor) ProposeFork(opts *bind.TransactOpts, _propNewTellorAddress common.Address) (*types.Transaction, error)

ProposeFork is a paid mutator transaction binding the contract method 0x26b7d9f6.

Solidity: function proposeFork(_propNewTellorAddress address) returns()

func (*TellorTransactor) RequestData 

func (_Tellor *TellorTransactor) RequestData(opts *bind.TransactOpts, _c_sapi string, _c_symbol string, _granularity *big.Int, _tip *big.Int) (*types.Transaction, error)

RequestData is a paid mutator transaction binding the contract method 0x3fff2816.

Solidity: function requestData(_c_sapi string, _c_symbol string, _granularity uint256, _tip uint256) returns()

func (*TellorTransactor) RequestStakingWithdraw 

func (_Tellor *TellorTransactor) RequestStakingWithdraw(opts *bind.TransactOpts) (*types.Transaction, error)

RequestStakingWithdraw is a paid mutator transaction binding the contract method 0x28449c3a.

Solidity: function requestStakingWithdraw() returns()

func (*TellorTransactor) SubmitMiningSolution 

func (_Tellor *TellorTransactor) SubmitMiningSolution(opts *bind.TransactOpts, _nonce string, _requestId *big.Int, _value *big.Int) (*types.Transaction, error)

SubmitMiningSolution is a paid mutator transaction binding the contract method 0x68c180d5.

Solidity: function submitMiningSolution(_nonce string, _requestId uint256, _value uint256) returns()

func (*TellorTransactor) TallyVotes 

func (_Tellor *TellorTransactor) TallyVotes(opts *bind.TransactOpts, _disputeId *big.Int) (*types.Transaction, error)

TallyVotes is a paid mutator transaction binding the contract method 0x4d318b0e.

Solidity: function tallyVotes(_disputeId uint256) returns()

func (*TellorTransactor) TheLazyCoon 

func (_Tellor *TellorTransactor) TheLazyCoon(opts *bind.TransactOpts, _address common.Address, _amount *big.Int) (*types.Transaction, error)

TheLazyCoon is a paid mutator transaction binding the contract method 0xb079f64a.

Solidity: function theLazyCoon(_address address, _amount uint256) returns()

func (*TellorTransactor) Transfer 

func (_Tellor *TellorTransactor) Transfer(opts *bind.TransactOpts, _to common.Address, _amount *big.Int) (*types.Transaction, error)

Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.

Solidity: function transfer(_to address, _amount uint256) returns(bool)

func (*TellorTransactor) TransferFrom 

func (_Tellor *TellorTransactor) TransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, _amount *big.Int) (*types.Transaction, error)

TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.

Solidity: function transferFrom(_from address, _to address, _amount uint256) returns(bool)

func (*TellorTransactor) TransferOwnership 

func (_Tellor *TellorTransactor) TransferOwnership(opts *bind.TransactOpts, _newOwner common.Address) (*types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(_newOwner address) returns()

func (*TellorTransactor) Vote 

func (_Tellor *TellorTransactor) Vote(opts *bind.TransactOpts, _disputeId *big.Int, _supportsDispute bool) (*types.Transaction, error)

Vote is a paid mutator transaction binding the contract method 0xc9d27afe.

Solidity: function vote(_disputeId uint256, _supportsDispute bool) returns()

func (*TellorTransactor) WithdrawStake 

func (_Tellor *TellorTransactor) WithdrawStake(opts *bind.TransactOpts) (*types.Transaction, error)

WithdrawStake is a paid mutator transaction binding the contract method 0xbed9d861.

Solidity: function withdrawStake() returns()

type TellorTransactorRaw 

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

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

func (*TellorTransactorRaw) Transact 

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

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

func (*TellorTransactorRaw) Transfer 

func (_Tellor *TellorTransactorRaw) 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 TellorTransactorSession 

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

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

func (*TellorTransactorSession) AddTip 

func (_Tellor *TellorTransactorSession) AddTip(_requestId *big.Int, _tip *big.Int) (*types.Transaction, error)

AddTip is a paid mutator transaction binding the contract method 0x752d49a1.

Solidity: function addTip(_requestId uint256, _tip uint256) returns()

func (*TellorTransactorSession) Approve 

func (_Tellor *TellorTransactorSession) Approve(_spender common.Address, _amount *big.Int) (*types.Transaction, error)

Approve is a paid mutator transaction binding the contract method 0x095ea7b3.

Solidity: function approve(_spender address, _amount uint256) returns(bool)

func (*TellorTransactorSession) BeginDispute 

func (_Tellor *TellorTransactorSession) BeginDispute(_requestId *big.Int, _timestamp *big.Int, _minerIndex *big.Int) (*types.Transaction, error)

BeginDispute is a paid mutator transaction binding the contract method 0x8581af19.

Solidity: function beginDispute(_requestId uint256, _timestamp uint256, _minerIndex uint256) returns()

func (*TellorTransactorSession) DepositStake 

func (_Tellor *TellorTransactorSession) DepositStake() (*types.Transaction, error)

DepositStake is a paid mutator transaction binding the contract method 0x0d2d76a2.

Solidity: function depositStake() returns()

func (*TellorTransactorSession) ProposeFork 

func (_Tellor *TellorTransactorSession) ProposeFork(_propNewTellorAddress common.Address) (*types.Transaction, error)

ProposeFork is a paid mutator transaction binding the contract method 0x26b7d9f6.

Solidity: function proposeFork(_propNewTellorAddress address) returns()

func (*TellorTransactorSession) RequestData 

func (_Tellor *TellorTransactorSession) RequestData(_c_sapi string, _c_symbol string, _granularity *big.Int, _tip *big.Int) (*types.Transaction, error)

RequestData is a paid mutator transaction binding the contract method 0x3fff2816.

Solidity: function requestData(_c_sapi string, _c_symbol string, _granularity uint256, _tip uint256) returns()

func (*TellorTransactorSession) RequestStakingWithdraw 

func (_Tellor *TellorTransactorSession) RequestStakingWithdraw() (*types.Transaction, error)

RequestStakingWithdraw is a paid mutator transaction binding the contract method 0x28449c3a.

Solidity: function requestStakingWithdraw() returns()

func (*TellorTransactorSession) SubmitMiningSolution 

func (_Tellor *TellorTransactorSession) SubmitMiningSolution(_nonce string, _requestId *big.Int, _value *big.Int) (*types.Transaction, error)

SubmitMiningSolution is a paid mutator transaction binding the contract method 0x68c180d5.

Solidity: function submitMiningSolution(_nonce string, _requestId uint256, _value uint256) returns()

func (*TellorTransactorSession) TallyVotes 

func (_Tellor *TellorTransactorSession) TallyVotes(_disputeId *big.Int) (*types.Transaction, error)

TallyVotes is a paid mutator transaction binding the contract method 0x4d318b0e.

Solidity: function tallyVotes(_disputeId uint256) returns()

func (*TellorTransactorSession) TheLazyCoon 

func (_Tellor *TellorTransactorSession) TheLazyCoon(_address common.Address, _amount *big.Int) (*types.Transaction, error)

TheLazyCoon is a paid mutator transaction binding the contract method 0xb079f64a.

Solidity: function theLazyCoon(_address address, _amount uint256) returns()

func (*TellorTransactorSession) Transfer 

func (_Tellor *TellorTransactorSession) Transfer(_to common.Address, _amount *big.Int) (*types.Transaction, error)

Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.

Solidity: function transfer(_to address, _amount uint256) returns(bool)

func (*TellorTransactorSession) TransferFrom 

func (_Tellor *TellorTransactorSession) TransferFrom(_from common.Address, _to common.Address, _amount *big.Int) (*types.Transaction, error)

TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.

Solidity: function transferFrom(_from address, _to address, _amount uint256) returns(bool)

func (*TellorTransactorSession) TransferOwnership 

func (_Tellor *TellorTransactorSession) TransferOwnership(_newOwner common.Address) (*types.Transaction, error)

TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.

Solidity: function transferOwnership(_newOwner address) returns()

func (*TellorTransactorSession) Vote 

func (_Tellor *TellorTransactorSession) Vote(_disputeId *big.Int, _supportsDispute bool) (*types.Transaction, error)

Vote is a paid mutator transaction binding the contract method 0xc9d27afe.

Solidity: function vote(_disputeId uint256, _supportsDispute bool) returns()

func (*TellorTransactorSession) WithdrawStake 

func (_Tellor *TellorTransactorSession) WithdrawStake() (*types.Transaction, error)

WithdrawStake is a paid mutator transaction binding the contract method 0xbed9d861.

Solidity: function withdrawStake() returns()

type TellorTransfer 

type TellorTransfer struct {
	TellorTransferCaller     // Read-only binding to the contract
	TellorTransferTransactor // Write-only binding to the contract
	TellorTransferFilterer   // Log filterer for contract events
}

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

func DeployTellorTransfer 

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

DeployTellorTransfer deploys a new Ethereum contract, binding an instance of TellorTransfer to it.

func NewTellorTransfer 

func NewTellorTransfer(address common.Address, backend bind.ContractBackend) (*TellorTransfer, error)

NewTellorTransfer creates a new instance of TellorTransfer, bound to a specific deployed contract.

type TellorTransferApproval 

type TellorTransferApproval struct {
	Owner   common.Address
	Spender common.Address
	Value   *big.Int
	Raw     types.Log // Blockchain specific contextual infos
}

TellorTransferApproval represents a Approval event raised by the TellorTransfer contract.

type TellorTransferApprovalIterator 

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

TellorTransferApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the TellorTransfer contract.

func (*TellorTransferApprovalIterator) Close 

func (it *TellorTransferApprovalIterator) Close() error

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

func (*TellorTransferApprovalIterator) Error 

func (it *TellorTransferApprovalIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TellorTransferApprovalIterator) Next 

func (it *TellorTransferApprovalIterator) 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 TellorTransferCaller 

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

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

func NewTellorTransferCaller 

func NewTellorTransferCaller(address common.Address, caller bind.ContractCaller) (*TellorTransferCaller, error)

NewTellorTransferCaller creates a new read-only instance of TellorTransfer, bound to a specific deployed contract.

type TellorTransferCallerRaw 

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

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

func (*TellorTransferCallerRaw) Call 

func (_TellorTransfer *TellorTransferCallerRaw) 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 TellorTransferCallerSession 

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

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

type TellorTransferFilterer 

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

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

func NewTellorTransferFilterer 

func NewTellorTransferFilterer(address common.Address, filterer bind.ContractFilterer) (*TellorTransferFilterer, error)

NewTellorTransferFilterer creates a new log filterer instance of TellorTransfer, bound to a specific deployed contract.

func (*TellorTransferFilterer) FilterApproval 

func (_TellorTransfer *TellorTransferFilterer) FilterApproval(opts *bind.FilterOpts, _owner []common.Address, _spender []common.Address) (*TellorTransferApprovalIterator, error)

FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.

Solidity: e Approval(_owner indexed address, _spender indexed address, _value uint256)

func (*TellorTransferFilterer) FilterTransfer 

func (_TellorTransfer *TellorTransferFilterer) FilterTransfer(opts *bind.FilterOpts, _from []common.Address, _to []common.Address) (*TellorTransferTransferIterator, error)

FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.

Solidity: e Transfer(_from indexed address, _to indexed address, _value uint256)

func (*TellorTransferFilterer) WatchApproval 

func (_TellorTransfer *TellorTransferFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *TellorTransferApproval, _owner []common.Address, _spender []common.Address) (event.Subscription, error)

WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.

Solidity: e Approval(_owner indexed address, _spender indexed address, _value uint256)

func (*TellorTransferFilterer) WatchTransfer 

func (_TellorTransfer *TellorTransferFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *TellorTransferTransfer, _from []common.Address, _to []common.Address) (event.Subscription, error)

WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.

Solidity: e Transfer(_from indexed address, _to indexed address, _value uint256)

type TellorTransferRaw 

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

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

func (*TellorTransferRaw) Call 

func (_TellorTransfer *TellorTransferRaw) 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 (*TellorTransferRaw) Transact 

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

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

func (*TellorTransferRaw) Transfer 

func (_TellorTransfer *TellorTransferRaw) 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 TellorTransferSession 

type TellorTransferSession struct {
	Contract     *TellorTransfer   // 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
}

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

type TellorTransferTransactor 

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

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

func NewTellorTransferTransactor 

func NewTellorTransferTransactor(address common.Address, transactor bind.ContractTransactor) (*TellorTransferTransactor, error)

NewTellorTransferTransactor creates a new write-only instance of TellorTransfer, bound to a specific deployed contract.

type TellorTransferTransactorRaw 

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

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

func (*TellorTransferTransactorRaw) Transact 

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

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

func (*TellorTransferTransactorRaw) Transfer 

func (_TellorTransfer *TellorTransferTransactorRaw) 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 TellorTransferTransactorSession 

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

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

type TellorTransferTransfer 

type TellorTransferTransfer struct {
	From  common.Address
	To    common.Address
	Value *big.Int
	Raw   types.Log // Blockchain specific contextual infos
}

TellorTransferTransfer represents a Transfer event raised by the TellorTransfer contract.

type TellorTransferTransferIterator 

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

TellorTransferTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the TellorTransfer contract.

func (*TellorTransferTransferIterator) Close 

func (it *TellorTransferTransferIterator) Close() error

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

func (*TellorTransferTransferIterator) Error 

func (it *TellorTransferTransferIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*TellorTransferTransferIterator) Next 

func (it *TellorTransferTransferIterator) 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 Utilities 

type Utilities struct {
	UtilitiesCaller     // Read-only binding to the contract
	UtilitiesTransactor // Write-only binding to the contract
	UtilitiesFilterer   // Log filterer for contract events
}

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

func DeployUtilities 

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

DeployUtilities deploys a new Ethereum contract, binding an instance of Utilities to it.

func NewUtilities 

func NewUtilities(address common.Address, backend bind.ContractBackend) (*Utilities, error)

NewUtilities creates a new instance of Utilities, bound to a specific deployed contract.

type UtilitiesCaller 

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

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

func NewUtilitiesCaller 

func NewUtilitiesCaller(address common.Address, caller bind.ContractCaller) (*UtilitiesCaller, error)

NewUtilitiesCaller creates a new read-only instance of Utilities, bound to a specific deployed contract.

type UtilitiesCallerRaw 

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

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

func (*UtilitiesCallerRaw) Call 

func (_Utilities *UtilitiesCallerRaw) 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 UtilitiesCallerSession 

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

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

type UtilitiesFilterer 

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

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

func NewUtilitiesFilterer 

func NewUtilitiesFilterer(address common.Address, filterer bind.ContractFilterer) (*UtilitiesFilterer, error)

NewUtilitiesFilterer creates a new log filterer instance of Utilities, bound to a specific deployed contract.

type UtilitiesRaw 

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

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

func (*UtilitiesRaw) Call 

func (_Utilities *UtilitiesRaw) 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 (*UtilitiesRaw) Transact 

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

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

func (*UtilitiesRaw) Transfer 

func (_Utilities *UtilitiesRaw) 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 UtilitiesSession 

type UtilitiesSession struct {
	Contract     *Utilities        // 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
}

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

type UtilitiesTransactor 

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

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

func NewUtilitiesTransactor 

func NewUtilitiesTransactor(address common.Address, transactor bind.ContractTransactor) (*UtilitiesTransactor, error)

NewUtilitiesTransactor creates a new write-only instance of Utilities, bound to a specific deployed contract.

type UtilitiesTransactorRaw 

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

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

func (*UtilitiesTransactorRaw) Transact 

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

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

func (*UtilitiesTransactorRaw) Transfer 

func (_Utilities *UtilitiesTransactorRaw) 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 UtilitiesTransactorSession 

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

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