ethereum

package
v0.0.0-...-ba55b63 Latest Latest
Warning

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

 Go to latest Published: Dec 13, 2023 License: MIT Imports: 19 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var EthereumABI = EthereumMetaData.ABI

EthereumABI is the input ABI used to generate the binding from. Deprecated: Use EthereumMetaData.ABI instead.

View Source 
var EthereumMetaData = &bind.MetaData{
	ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"encryptedKey\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"tau\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"rSignature\",\"type\":\"bytes\"}],\"name\":\"dataRequest\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"encryptedData\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"encryptedKey\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"name\":\"dataResponse\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"encryptedKey\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"tau\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"rSignature\",\"type\":\"bytes\"}],\"name\":\"requireOracleData\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"encryptedData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"encryptedKey\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"name\":\"respondOracleData\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
}

EthereumMetaData contains all meta data concerning the Ethereum contract.

View Source 
var ProxyABI = ProxyMetaData.ABI

ProxyABI is the input ABI used to generate the binding from. Deprecated: Use ProxyMetaData.ABI instead.

View Source 
var ProxyMetaData = &bind.MetaData{
	ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"reqSource\",\"type\":\"bytes\"}],\"name\":\"dataRequest\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"sourceData\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"reqSource\",\"type\":\"bytes\"}],\"name\":\"dataResponse\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"reqSource\",\"type\":\"bytes\"}],\"name\":\"requireOracleData\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"sourceData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"reqSource\",\"type\":\"bytes\"}],\"name\":\"respondOracleData\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
}

ProxyMetaData contains all meta data concerning the Proxy contract.

Functions

This section is empty.

Types

type Client 

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

func NewEthereumClient 

func NewEthereumClient(providerAddr, contractAddr string) (*Client, error)

NewEthereumClient Create new client with provider http/ws address

func (*Client) CallContractRequireData 

func (c *Client) CallContractRequireData(encryptedKey, tau,
	rSignature []byte) (*string, error)

func (*Client) CallContractResponseData 

func (c *Client) CallContractResponseData(encryptedKey, encryptedData,
	signature []byte) (*string, error)

func (*Client) ListenContractEvent 

func (c *Client) ListenContractEvent(encryptedKey []byte, topics [][]common.Hash) (
	*EthereumDataResponse, error)

func (*Client) OracleListenContractEvent 

func (c *Client) OracleListenContractEvent(
	interval int64, secret string, eventChan chan *EthereumDataRequest) (
	*EthereumDataResponse, error)

type Ethereum 

type Ethereum struct {
	EthereumCaller     // Read-only binding to the contract
	EthereumTransactor // Write-only binding to the contract
	EthereumFilterer   // Log filterer for contract events
}

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

func NewEthereum 

func NewEthereum(address common.Address, backend bind.ContractBackend) (*Ethereum, error)

NewEthereum creates a new instance of Ethereum, bound to a specific deployed contract.

type EthereumCaller 

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

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

func NewEthereumCaller 

func NewEthereumCaller(address common.Address, caller bind.ContractCaller) (*EthereumCaller, error)

NewEthereumCaller creates a new read-only instance of Ethereum, bound to a specific deployed contract.

type EthereumCallerRaw 

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

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

func (*EthereumCallerRaw) Call 

func (_Ethereum *EthereumCallerRaw) 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 EthereumCallerSession 

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

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

type EthereumDataRequest 

type EthereumDataRequest struct {
	EncryptedKey []byte
	Tau          []byte
	RSignature   []byte
	Raw          types.Log // Blockchain specific contextual infos
}

EthereumDataRequest represents a DataRequest event raised by the Ethereum contract.

type EthereumDataRequestIterator 

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

EthereumDataRequestIterator is returned from FilterDataRequest and is used to iterate over the raw logs and unpacked data for DataRequest events raised by the Ethereum contract.

func (*EthereumDataRequestIterator) Close 

func (it *EthereumDataRequestIterator) Close() error

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

func (*EthereumDataRequestIterator) Error 

func (it *EthereumDataRequestIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EthereumDataRequestIterator) Next 

func (it *EthereumDataRequestIterator) 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 EthereumDataResponse 

type EthereumDataResponse struct {
	EncryptedData []byte
	EncryptedKey  []byte
	Signature     []byte
	Raw           types.Log // Blockchain specific contextual infos
}

EthereumDataResponse represents a DataResponse event raised by the Ethereum contract.

type EthereumDataResponseIterator 

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

EthereumDataResponseIterator is returned from FilterDataResponse and is used to iterate over the raw logs and unpacked data for DataResponse events raised by the Ethereum contract.

func (*EthereumDataResponseIterator) Close 

func (it *EthereumDataResponseIterator) Close() error

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

func (*EthereumDataResponseIterator) Error 

func (it *EthereumDataResponseIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*EthereumDataResponseIterator) Next 

func (it *EthereumDataResponseIterator) 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 EthereumFilterer 

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

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

func NewEthereumFilterer 

func NewEthereumFilterer(address common.Address, filterer bind.ContractFilterer) (*EthereumFilterer, error)

NewEthereumFilterer creates a new log filterer instance of Ethereum, bound to a specific deployed contract.

func (*EthereumFilterer) FilterDataRequest 

func (_Ethereum *EthereumFilterer) FilterDataRequest(opts *bind.FilterOpts) (*EthereumDataRequestIterator, error)

FilterDataRequest is a free log retrieval operation binding the contract event 0x55f6a9c9e937fcf2a23e13d208d4008e5baf112e5703f1956a9cf8cb9e4ea46e.

Solidity: event dataRequest(bytes encryptedKey, bytes tau, bytes rSignature)

func (*EthereumFilterer) FilterDataResponse 

func (_Ethereum *EthereumFilterer) FilterDataResponse(opts *bind.FilterOpts) (*EthereumDataResponseIterator, error)

FilterDataResponse is a free log retrieval operation binding the contract event 0x723a51d62591fc948ca09f58283b246c6c40e4c8c897a7e462330e654d582d77.

Solidity: event dataResponse(bytes encryptedData, bytes encryptedKey, bytes signature)

func (*EthereumFilterer) ParseDataRequest 

func (_Ethereum *EthereumFilterer) ParseDataRequest(log types.Log) (*EthereumDataRequest, error)

ParseDataRequest is a log parse operation binding the contract event 0x55f6a9c9e937fcf2a23e13d208d4008e5baf112e5703f1956a9cf8cb9e4ea46e.

Solidity: event dataRequest(bytes encryptedKey, bytes tau, bytes rSignature)

func (*EthereumFilterer) ParseDataResponse 

func (_Ethereum *EthereumFilterer) ParseDataResponse(log types.Log) (*EthereumDataResponse, error)

ParseDataResponse is a log parse operation binding the contract event 0x723a51d62591fc948ca09f58283b246c6c40e4c8c897a7e462330e654d582d77.

Solidity: event dataResponse(bytes encryptedData, bytes encryptedKey, bytes signature)

func (*EthereumFilterer) WatchDataRequest 

func (_Ethereum *EthereumFilterer) WatchDataRequest(opts *bind.WatchOpts, sink chan<- *EthereumDataRequest) (event.Subscription, error)

WatchDataRequest is a free log subscription operation binding the contract event 0x55f6a9c9e937fcf2a23e13d208d4008e5baf112e5703f1956a9cf8cb9e4ea46e.

Solidity: event dataRequest(bytes encryptedKey, bytes tau, bytes rSignature)

func (*EthereumFilterer) WatchDataResponse 

func (_Ethereum *EthereumFilterer) WatchDataResponse(opts *bind.WatchOpts, sink chan<- *EthereumDataResponse) (event.Subscription, error)

WatchDataResponse is a free log subscription operation binding the contract event 0x723a51d62591fc948ca09f58283b246c6c40e4c8c897a7e462330e654d582d77.

Solidity: event dataResponse(bytes encryptedData, bytes encryptedKey, bytes signature)

type EthereumRaw 

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

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

func (*EthereumRaw) Call 

func (_Ethereum *EthereumRaw) 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 (*EthereumRaw) Transact 

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

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

func (*EthereumRaw) Transfer 

func (_Ethereum *EthereumRaw) 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 EthereumSession 

type EthereumSession struct {
	Contract     *Ethereum         // 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
}

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

func (*EthereumSession) RequireOracleData 

func (_Ethereum *EthereumSession) RequireOracleData(encryptedKey []byte, tau []byte, rSignature []byte) (*types.Transaction, error)

RequireOracleData is a paid mutator transaction binding the contract method 0x1d07fbfd.

Solidity: function requireOracleData(bytes encryptedKey, bytes tau, bytes rSignature) returns()

func (*EthereumSession) RespondOracleData 

func (_Ethereum *EthereumSession) RespondOracleData(encryptedData []byte, encryptedKey []byte, signature []byte) (*types.Transaction, error)

RespondOracleData is a paid mutator transaction binding the contract method 0x38994589.

Solidity: function respondOracleData(bytes encryptedData, bytes encryptedKey, bytes signature) returns()

type EthereumTransactor 

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

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

func NewEthereumTransactor 

func NewEthereumTransactor(address common.Address, transactor bind.ContractTransactor) (*EthereumTransactor, error)

NewEthereumTransactor creates a new write-only instance of Ethereum, bound to a specific deployed contract.

func (*EthereumTransactor) RequireOracleData 

func (_Ethereum *EthereumTransactor) RequireOracleData(opts *bind.TransactOpts, encryptedKey []byte, tau []byte, rSignature []byte) (*types.Transaction, error)

RequireOracleData is a paid mutator transaction binding the contract method 0x1d07fbfd.

Solidity: function requireOracleData(bytes encryptedKey, bytes tau, bytes rSignature) returns()

func (*EthereumTransactor) RespondOracleData 

func (_Ethereum *EthereumTransactor) RespondOracleData(opts *bind.TransactOpts, encryptedData []byte, encryptedKey []byte, signature []byte) (*types.Transaction, error)

RespondOracleData is a paid mutator transaction binding the contract method 0x38994589.

Solidity: function respondOracleData(bytes encryptedData, bytes encryptedKey, bytes signature) returns()

type EthereumTransactorRaw 

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

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

func (*EthereumTransactorRaw) Transact 

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

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

func (*EthereumTransactorRaw) Transfer 

func (_Ethereum *EthereumTransactorRaw) 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 EthereumTransactorSession 

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

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

func (*EthereumTransactorSession) RequireOracleData 

func (_Ethereum *EthereumTransactorSession) RequireOracleData(encryptedKey []byte, tau []byte, rSignature []byte) (*types.Transaction, error)

RequireOracleData is a paid mutator transaction binding the contract method 0x1d07fbfd.

Solidity: function requireOracleData(bytes encryptedKey, bytes tau, bytes rSignature) returns()

func (*EthereumTransactorSession) RespondOracleData 

func (_Ethereum *EthereumTransactorSession) RespondOracleData(encryptedData []byte, encryptedKey []byte, signature []byte) (*types.Transaction, error)

RespondOracleData is a paid mutator transaction binding the contract method 0x38994589.

Solidity: function respondOracleData(bytes encryptedData, bytes encryptedKey, bytes signature) returns()

type Proxy 

type Proxy struct {
	ProxyCaller     // Read-only binding to the contract
	ProxyTransactor // Write-only binding to the contract
	ProxyFilterer   // Log filterer for contract events
}

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

func NewProxy 

func NewProxy(address common.Address, backend bind.ContractBackend) (*Proxy, error)

NewProxy creates a new instance of Proxy, bound to a specific deployed contract.

type ProxyCaller 

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

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

func NewProxyCaller 

func NewProxyCaller(address common.Address, caller bind.ContractCaller) (*ProxyCaller, error)

NewProxyCaller creates a new read-only instance of Proxy, bound to a specific deployed contract.

type ProxyCallerRaw 

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

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

func (*ProxyCallerRaw) Call 

func (_Proxy *ProxyCallerRaw) 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 ProxyCallerSession 

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

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

type ProxyDataRequest 

type ProxyDataRequest struct {
	ReqSource []byte
	Raw       types.Log // Blockchain specific contextual infos
}

ProxyDataRequest represents a DataRequest event raised by the Proxy contract.

type ProxyDataRequestIterator 

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

ProxyDataRequestIterator is returned from FilterDataRequest and is used to iterate over the raw logs and unpacked data for DataRequest events raised by the Proxy contract.

func (*ProxyDataRequestIterator) Close 

func (it *ProxyDataRequestIterator) Close() error

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

func (*ProxyDataRequestIterator) Error 

func (it *ProxyDataRequestIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ProxyDataRequestIterator) Next 

func (it *ProxyDataRequestIterator) 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 ProxyDataResponse 

type ProxyDataResponse struct {
	SourceData []byte
	ReqSource  []byte
	Raw        types.Log // Blockchain specific contextual infos
}

ProxyDataResponse represents a DataResponse event raised by the Proxy contract.

type ProxyDataResponseIterator 

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

ProxyDataResponseIterator is returned from FilterDataResponse and is used to iterate over the raw logs and unpacked data for DataResponse events raised by the Proxy contract.

func (*ProxyDataResponseIterator) Close 

func (it *ProxyDataResponseIterator) Close() error

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

func (*ProxyDataResponseIterator) Error 

func (it *ProxyDataResponseIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ProxyDataResponseIterator) Next 

func (it *ProxyDataResponseIterator) 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 ProxyFilterer 

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

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

func NewProxyFilterer 

func NewProxyFilterer(address common.Address, filterer bind.ContractFilterer) (*ProxyFilterer, error)

NewProxyFilterer creates a new log filterer instance of Proxy, bound to a specific deployed contract.

func (*ProxyFilterer) FilterDataRequest 

func (_Proxy *ProxyFilterer) FilterDataRequest(opts *bind.FilterOpts) (*ProxyDataRequestIterator, error)

FilterDataRequest is a free log retrieval operation binding the contract event 0x2e8181db9d458de9cc4a18cd7927f32e2e0499a5d24eacfa49247fa1bfaa057f.

Solidity: event dataRequest(bytes reqSource)

func (*ProxyFilterer) FilterDataResponse 

func (_Proxy *ProxyFilterer) FilterDataResponse(opts *bind.FilterOpts) (*ProxyDataResponseIterator, error)

FilterDataResponse is a free log retrieval operation binding the contract event 0xd42fe4a1d37c99453a3e84823384d75d5b9ea59c92433284de2371340b7df7a8.

Solidity: event dataResponse(bytes sourceData, bytes reqSource)

func (*ProxyFilterer) ParseDataRequest 

func (_Proxy *ProxyFilterer) ParseDataRequest(log types.Log) (*ProxyDataRequest, error)

ParseDataRequest is a log parse operation binding the contract event 0x2e8181db9d458de9cc4a18cd7927f32e2e0499a5d24eacfa49247fa1bfaa057f.

Solidity: event dataRequest(bytes reqSource)

func (*ProxyFilterer) ParseDataResponse 

func (_Proxy *ProxyFilterer) ParseDataResponse(log types.Log) (*ProxyDataResponse, error)

ParseDataResponse is a log parse operation binding the contract event 0xd42fe4a1d37c99453a3e84823384d75d5b9ea59c92433284de2371340b7df7a8.

Solidity: event dataResponse(bytes sourceData, bytes reqSource)

func (*ProxyFilterer) WatchDataRequest 

func (_Proxy *ProxyFilterer) WatchDataRequest(opts *bind.WatchOpts, sink chan<- *ProxyDataRequest) (event.Subscription, error)

WatchDataRequest is a free log subscription operation binding the contract event 0x2e8181db9d458de9cc4a18cd7927f32e2e0499a5d24eacfa49247fa1bfaa057f.

Solidity: event dataRequest(bytes reqSource)

func (*ProxyFilterer) WatchDataResponse 

func (_Proxy *ProxyFilterer) WatchDataResponse(opts *bind.WatchOpts, sink chan<- *ProxyDataResponse) (event.Subscription, error)

WatchDataResponse is a free log subscription operation binding the contract event 0xd42fe4a1d37c99453a3e84823384d75d5b9ea59c92433284de2371340b7df7a8.

Solidity: event dataResponse(bytes sourceData, bytes reqSource)

type ProxyRaw 

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

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

func (*ProxyRaw) Call 

func (_Proxy *ProxyRaw) 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 (*ProxyRaw) Transact 

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

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

func (*ProxyRaw) Transfer 

func (_Proxy *ProxyRaw) 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 ProxySession 

type ProxySession struct {
	Contract     *Proxy            // 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
}

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

func (*ProxySession) RequireOracleData 

func (_Proxy *ProxySession) RequireOracleData(reqSource []byte) (*types.Transaction, error)

RequireOracleData is a paid mutator transaction binding the contract method 0xf84a3d2d.

Solidity: function requireOracleData(bytes reqSource) returns()

func (*ProxySession) RespondOracleData 

func (_Proxy *ProxySession) RespondOracleData(sourceData []byte, reqSource []byte) (*types.Transaction, error)

RespondOracleData is a paid mutator transaction binding the contract method 0x6b22545b.

Solidity: function respondOracleData(bytes sourceData, bytes reqSource) returns()

type ProxyTransactor 

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

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

func NewProxyTransactor 

func NewProxyTransactor(address common.Address, transactor bind.ContractTransactor) (*ProxyTransactor, error)

NewProxyTransactor creates a new write-only instance of Proxy, bound to a specific deployed contract.

func (*ProxyTransactor) RequireOracleData 

func (_Proxy *ProxyTransactor) RequireOracleData(opts *bind.TransactOpts, reqSource []byte) (*types.Transaction, error)

RequireOracleData is a paid mutator transaction binding the contract method 0xf84a3d2d.

Solidity: function requireOracleData(bytes reqSource) returns()

func (*ProxyTransactor) RespondOracleData 

func (_Proxy *ProxyTransactor) RespondOracleData(opts *bind.TransactOpts, sourceData []byte, reqSource []byte) (*types.Transaction, error)

RespondOracleData is a paid mutator transaction binding the contract method 0x6b22545b.

Solidity: function respondOracleData(bytes sourceData, bytes reqSource) returns()

type ProxyTransactorRaw 

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

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

func (*ProxyTransactorRaw) Transact 

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

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

func (*ProxyTransactorRaw) Transfer 

func (_Proxy *ProxyTransactorRaw) 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 ProxyTransactorSession 

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

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

func (*ProxyTransactorSession) RequireOracleData 

func (_Proxy *ProxyTransactorSession) RequireOracleData(reqSource []byte) (*types.Transaction, error)

RequireOracleData is a paid mutator transaction binding the contract method 0xf84a3d2d.

Solidity: function requireOracleData(bytes reqSource) returns()

func (*ProxyTransactorSession) RespondOracleData 

func (_Proxy *ProxyTransactorSession) RespondOracleData(sourceData []byte, reqSource []byte) (*types.Transaction, error)

RespondOracleData is a paid mutator transaction binding the contract method 0x6b22545b.

Solidity: function respondOracleData(bytes sourceData, bytes reqSource) returns()

type WDClient 

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

func NewWDEthereumClient 

func NewWDEthereumClient(providerAddr, contractAddr string) (*WDClient, error)

NewWDEthereumClient Create new client with provider http/ws address

func (*WDClient) CallContractRequireData 

func (c *WDClient) CallContractRequireData(reqSource []byte) (*string, error)

func (*WDClient) CallContractResponseData 

func (c *WDClient) CallContractResponseData(encryptedKey,
	encryptedData []byte) (*string, error)

func (*WDClient) ListenContractEvent 

func (c *WDClient) ListenContractEvent(reqSource []byte, topics [][]common.Hash) (
	*ProxyDataResponse, error)

func (*WDClient) OracleListenContractEvent 

func (c *WDClient) OracleListenContractEvent(
	eventChan chan *ProxyDataRequest) (
	*ProxyDataResponse, error)

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.