abi

package
v0.0.0-...-40b4f63 Latest Latest
Warning

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

 Go to latest Published: Oct 14, 2020 License: MIT Imports: 8 Imported by: 0

Documentation

Index

Constants

View Source 
const DepositLogABI = "" /* 8479-byte string literal not displayed */

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

Variables

This section is empty.

Functions

This section is empty.

Types

type DepositLog 

type DepositLog struct {
	DepositLogCaller     // Read-only binding to the contract
	DepositLogTransactor // Write-only binding to the contract
	DepositLogFilterer   // Log filterer for contract events
}

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

func NewDepositLog 

func NewDepositLog(address common.Address, backend bind.ContractBackend) (*DepositLog, error)

NewDepositLog creates a new instance of DepositLog, bound to a specific deployed contract.

type DepositLogCaller 

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

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

func NewDepositLogCaller 

func NewDepositLogCaller(address common.Address, caller bind.ContractCaller) (*DepositLogCaller, error)

NewDepositLogCaller creates a new read-only instance of DepositLog, bound to a specific deployed contract.

func (*DepositLogCaller) ApprovedToLog 

func (_DepositLog *DepositLogCaller) ApprovedToLog(opts *bind.CallOpts, _caller common.Address) (bool, error)

ApprovedToLog is a free data retrieval call binding the contract method 0x9ffb3862.

Solidity: function approvedToLog(address _caller) constant returns(bool)

type DepositLogCallerRaw 

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

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

func (*DepositLogCallerRaw) Call 

func (_DepositLog *DepositLogCallerRaw) 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 DepositLogCallerSession 

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

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

func (*DepositLogCallerSession) ApprovedToLog 

func (_DepositLog *DepositLogCallerSession) ApprovedToLog(_caller common.Address) (bool, error)

ApprovedToLog is a free data retrieval call binding the contract method 0x9ffb3862.

Solidity: function approvedToLog(address _caller) constant returns(bool)

type DepositLogCourtesyCalled 

type DepositLogCourtesyCalled struct {
	DepositContractAddress common.Address
	Timestamp              *big.Int
	Raw                    types.Log // Blockchain specific contextual infos
}

DepositLogCourtesyCalled represents a CourtesyCalled event raised by the DepositLog contract.

type DepositLogCourtesyCalledIterator 

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

DepositLogCourtesyCalledIterator is returned from FilterCourtesyCalled and is used to iterate over the raw logs and unpacked data for CourtesyCalled events raised by the DepositLog contract.

func (*DepositLogCourtesyCalledIterator) Close 

func (it *DepositLogCourtesyCalledIterator) Close() error

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

func (*DepositLogCourtesyCalledIterator) Error 

func (it *DepositLogCourtesyCalledIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DepositLogCourtesyCalledIterator) Next 

func (it *DepositLogCourtesyCalledIterator) 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 DepositLogCreated 

type DepositLogCreated struct {
	DepositContractAddress common.Address
	KeepAddress            common.Address
	Timestamp              *big.Int
	Raw                    types.Log // Blockchain specific contextual infos
}

DepositLogCreated represents a Created event raised by the DepositLog contract.

type DepositLogCreatedIterator 

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

DepositLogCreatedIterator is returned from FilterCreated and is used to iterate over the raw logs and unpacked data for Created events raised by the DepositLog contract.

func (*DepositLogCreatedIterator) Close 

func (it *DepositLogCreatedIterator) Close() error

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

func (*DepositLogCreatedIterator) Error 

func (it *DepositLogCreatedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DepositLogCreatedIterator) Next 

func (it *DepositLogCreatedIterator) 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 DepositLogExitedCourtesyCall 

type DepositLogExitedCourtesyCall struct {
	DepositContractAddress common.Address
	Timestamp              *big.Int
	Raw                    types.Log // Blockchain specific contextual infos
}

DepositLogExitedCourtesyCall represents a ExitedCourtesyCall event raised by the DepositLog contract.

type DepositLogExitedCourtesyCallIterator 

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

DepositLogExitedCourtesyCallIterator is returned from FilterExitedCourtesyCall and is used to iterate over the raw logs and unpacked data for ExitedCourtesyCall events raised by the DepositLog contract.

func (*DepositLogExitedCourtesyCallIterator) Close 

func (it *DepositLogExitedCourtesyCallIterator) Close() error

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

func (*DepositLogExitedCourtesyCallIterator) Error 

func (it *DepositLogExitedCourtesyCallIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DepositLogExitedCourtesyCallIterator) Next 

func (it *DepositLogExitedCourtesyCallIterator) 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 DepositLogFilterer 

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

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

func NewDepositLogFilterer 

func NewDepositLogFilterer(address common.Address, filterer bind.ContractFilterer) (*DepositLogFilterer, error)

NewDepositLogFilterer creates a new log filterer instance of DepositLog, bound to a specific deployed contract.

func (*DepositLogFilterer) FilterCourtesyCalled 

func (_DepositLog *DepositLogFilterer) FilterCourtesyCalled(opts *bind.FilterOpts, _depositContractAddress []common.Address) (*DepositLogCourtesyCalledIterator, error)

FilterCourtesyCalled is a free log retrieval operation binding the contract event 0x6e7b45210b79c12cd1332babd8d86c0bbb9ca898a89ce0404f17064dbfba18c0.

Solidity: event CourtesyCalled(address indexed _depositContractAddress, uint256 _timestamp)

func (*DepositLogFilterer) FilterCreated 

func (_DepositLog *DepositLogFilterer) FilterCreated(opts *bind.FilterOpts, _depositContractAddress []common.Address, _keepAddress []common.Address) (*DepositLogCreatedIterator, error)

FilterCreated is a free log retrieval operation binding the contract event 0x822b3073be62c5c7f143c2dcd71ee266434ee935d90a1eec3be34710ac8ec1a2.

Solidity: event Created(address indexed _depositContractAddress, address indexed _keepAddress, uint256 _timestamp)

func (*DepositLogFilterer) FilterExitedCourtesyCall 

func (_DepositLog *DepositLogFilterer) FilterExitedCourtesyCall(opts *bind.FilterOpts, _depositContractAddress []common.Address) (*DepositLogExitedCourtesyCallIterator, error)

FilterExitedCourtesyCall is a free log retrieval operation binding the contract event 0x07f0eaafadb9abb1d28da85d4b4c74f1939fd61b535c7f5ab501f618f07e76ee.

Solidity: event ExitedCourtesyCall(address indexed _depositContractAddress, uint256 _timestamp)

func (*DepositLogFilterer) FilterFraudDuringSetup 

func (_DepositLog *DepositLogFilterer) FilterFraudDuringSetup(opts *bind.FilterOpts, _depositContractAddress []common.Address) (*DepositLogFraudDuringSetupIterator, error)

FilterFraudDuringSetup is a free log retrieval operation binding the contract event 0x1e61af503f1d7de21d5300094c18bf8700f82b2951a4d54dd2adda13f6b3da30.

Solidity: event FraudDuringSetup(address indexed _depositContractAddress, uint256 _timestamp)

func (*DepositLogFilterer) FilterFunded 

func (_DepositLog *DepositLogFilterer) FilterFunded(opts *bind.FilterOpts, _depositContractAddress []common.Address, _txid [][32]byte) (*DepositLogFundedIterator, error)

FilterFunded is a free log retrieval operation binding the contract event 0xe34c70bd3e03956978a5c76d2ea5f3a60819171afea6dee4fc12b2e45f72d43d.

Solidity: event Funded(address indexed _depositContractAddress, bytes32 indexed _txid, uint256 _timestamp)

func (*DepositLogFilterer) FilterFunderAbortRequested 

func (_DepositLog *DepositLogFilterer) FilterFunderAbortRequested(opts *bind.FilterOpts, _depositContractAddress []common.Address) (*DepositLogFunderAbortRequestedIterator, error)

FilterFunderAbortRequested is a free log retrieval operation binding the contract event 0xa6e9673b5d53b3fe3c62b6459720f9c2a1b129d4f69acb771404ba8681b6a930.

Solidity: event FunderAbortRequested(address indexed _depositContractAddress, bytes _abortOutputScript)

func (*DepositLogFilterer) FilterGotRedemptionSignature 

func (_DepositLog *DepositLogFilterer) FilterGotRedemptionSignature(opts *bind.FilterOpts, _depositContractAddress []common.Address, _digest [][32]byte) (*DepositLogGotRedemptionSignatureIterator, error)

FilterGotRedemptionSignature is a free log retrieval operation binding the contract event 0x7f7d7327762d01d2c4a552ea0be2bc5a76264574a80aa78083e691a840e509f2.

Solidity: event GotRedemptionSignature(address indexed _depositContractAddress, bytes32 indexed _digest, bytes32 _r, bytes32 _s, uint256 _timestamp)

func (*DepositLogFilterer) FilterLiquidated 

func (_DepositLog *DepositLogFilterer) FilterLiquidated(opts *bind.FilterOpts, _depositContractAddress []common.Address) (*DepositLogLiquidatedIterator, error)

FilterLiquidated is a free log retrieval operation binding the contract event 0xa5ee7a2b0254fce91deed604506790ed7fa072d0b14cba4859c3bc8955b9caac.

Solidity: event Liquidated(address indexed _depositContractAddress, uint256 _timestamp)

func (*DepositLogFilterer) FilterRedeemed 

func (_DepositLog *DepositLogFilterer) FilterRedeemed(opts *bind.FilterOpts, _depositContractAddress []common.Address, _txid [][32]byte) (*DepositLogRedeemedIterator, error)

FilterRedeemed is a free log retrieval operation binding the contract event 0x44b7f176bcc739b54bd0800fe491cbdea19df7d4d6b19c281462e6b4fc504344.

Solidity: event Redeemed(address indexed _depositContractAddress, bytes32 indexed _txid, uint256 _timestamp)

func (*DepositLogFilterer) FilterRedemptionRequested 

func (_DepositLog *DepositLogFilterer) FilterRedemptionRequested(opts *bind.FilterOpts, _depositContractAddress []common.Address, _requester []common.Address, _digest [][32]byte) (*DepositLogRedemptionRequestedIterator, error)

FilterRedemptionRequested is a free log retrieval operation binding the contract event 0x7959c380174061a21a3ba80243a032ba9cd10dc8bd1736d7e835c94e97a35a98.

Solidity: event RedemptionRequested(address indexed _depositContractAddress, address indexed _requester, bytes32 indexed _digest, uint256 _utxoValue, bytes _redeemerOutputScript, uint256 _requestedFee, bytes _outpoint)

func (*DepositLogFilterer) FilterRegisteredPubkey 

func (_DepositLog *DepositLogFilterer) FilterRegisteredPubkey(opts *bind.FilterOpts, _depositContractAddress []common.Address) (*DepositLogRegisteredPubkeyIterator, error)

FilterRegisteredPubkey is a free log retrieval operation binding the contract event 0x8ee737ab16909c4e9d1b750814a4393c9f84ab5d3a29c08c313b783fc846ae33.

Solidity: event RegisteredPubkey(address indexed _depositContractAddress, bytes32 _signingGroupPubkeyX, bytes32 _signingGroupPubkeyY, uint256 _timestamp)

func (*DepositLogFilterer) FilterSetupFailed 

func (_DepositLog *DepositLogFilterer) FilterSetupFailed(opts *bind.FilterOpts, _depositContractAddress []common.Address) (*DepositLogSetupFailedIterator, error)

FilterSetupFailed is a free log retrieval operation binding the contract event 0x8fd2cfb62a35fccc1ecef829f83a6c2f840b73dad49d3eaaa402909752086d4b.

Solidity: event SetupFailed(address indexed _depositContractAddress, uint256 _timestamp)

func (*DepositLogFilterer) FilterStartedLiquidation 

func (_DepositLog *DepositLogFilterer) FilterStartedLiquidation(opts *bind.FilterOpts, _depositContractAddress []common.Address) (*DepositLogStartedLiquidationIterator, error)

FilterStartedLiquidation is a free log retrieval operation binding the contract event 0xbef11c059eefba82a15aea8a3a89c86fd08d7711c88fa7daea2632a55488510c.

Solidity: event StartedLiquidation(address indexed _depositContractAddress, bool _wasFraud, uint256 _timestamp)

func (*DepositLogFilterer) ParseCourtesyCalled 

func (_DepositLog *DepositLogFilterer) ParseCourtesyCalled(log types.Log) (*DepositLogCourtesyCalled, error)

ParseCourtesyCalled is a log parse operation binding the contract event 0x6e7b45210b79c12cd1332babd8d86c0bbb9ca898a89ce0404f17064dbfba18c0.

Solidity: event CourtesyCalled(address indexed _depositContractAddress, uint256 _timestamp)

func (*DepositLogFilterer) ParseCreated 

func (_DepositLog *DepositLogFilterer) ParseCreated(log types.Log) (*DepositLogCreated, error)

ParseCreated is a log parse operation binding the contract event 0x822b3073be62c5c7f143c2dcd71ee266434ee935d90a1eec3be34710ac8ec1a2.

Solidity: event Created(address indexed _depositContractAddress, address indexed _keepAddress, uint256 _timestamp)

func (*DepositLogFilterer) ParseExitedCourtesyCall 

func (_DepositLog *DepositLogFilterer) ParseExitedCourtesyCall(log types.Log) (*DepositLogExitedCourtesyCall, error)

ParseExitedCourtesyCall is a log parse operation binding the contract event 0x07f0eaafadb9abb1d28da85d4b4c74f1939fd61b535c7f5ab501f618f07e76ee.

Solidity: event ExitedCourtesyCall(address indexed _depositContractAddress, uint256 _timestamp)

func (*DepositLogFilterer) ParseFraudDuringSetup 

func (_DepositLog *DepositLogFilterer) ParseFraudDuringSetup(log types.Log) (*DepositLogFraudDuringSetup, error)

ParseFraudDuringSetup is a log parse operation binding the contract event 0x1e61af503f1d7de21d5300094c18bf8700f82b2951a4d54dd2adda13f6b3da30.

Solidity: event FraudDuringSetup(address indexed _depositContractAddress, uint256 _timestamp)

func (*DepositLogFilterer) ParseFunded 

func (_DepositLog *DepositLogFilterer) ParseFunded(log types.Log) (*DepositLogFunded, error)

ParseFunded is a log parse operation binding the contract event 0xe34c70bd3e03956978a5c76d2ea5f3a60819171afea6dee4fc12b2e45f72d43d.

Solidity: event Funded(address indexed _depositContractAddress, bytes32 indexed _txid, uint256 _timestamp)

func (*DepositLogFilterer) ParseFunderAbortRequested 

func (_DepositLog *DepositLogFilterer) ParseFunderAbortRequested(log types.Log) (*DepositLogFunderAbortRequested, error)

ParseFunderAbortRequested is a log parse operation binding the contract event 0xa6e9673b5d53b3fe3c62b6459720f9c2a1b129d4f69acb771404ba8681b6a930.

Solidity: event FunderAbortRequested(address indexed _depositContractAddress, bytes _abortOutputScript)

func (*DepositLogFilterer) ParseGotRedemptionSignature 

func (_DepositLog *DepositLogFilterer) ParseGotRedemptionSignature(log types.Log) (*DepositLogGotRedemptionSignature, error)

ParseGotRedemptionSignature is a log parse operation binding the contract event 0x7f7d7327762d01d2c4a552ea0be2bc5a76264574a80aa78083e691a840e509f2.

Solidity: event GotRedemptionSignature(address indexed _depositContractAddress, bytes32 indexed _digest, bytes32 _r, bytes32 _s, uint256 _timestamp)

func (*DepositLogFilterer) ParseLiquidated 

func (_DepositLog *DepositLogFilterer) ParseLiquidated(log types.Log) (*DepositLogLiquidated, error)

ParseLiquidated is a log parse operation binding the contract event 0xa5ee7a2b0254fce91deed604506790ed7fa072d0b14cba4859c3bc8955b9caac.

Solidity: event Liquidated(address indexed _depositContractAddress, uint256 _timestamp)

func (*DepositLogFilterer) ParseRedeemed 

func (_DepositLog *DepositLogFilterer) ParseRedeemed(log types.Log) (*DepositLogRedeemed, error)

ParseRedeemed is a log parse operation binding the contract event 0x44b7f176bcc739b54bd0800fe491cbdea19df7d4d6b19c281462e6b4fc504344.

Solidity: event Redeemed(address indexed _depositContractAddress, bytes32 indexed _txid, uint256 _timestamp)

func (*DepositLogFilterer) ParseRedemptionRequested 

func (_DepositLog *DepositLogFilterer) ParseRedemptionRequested(log types.Log) (*DepositLogRedemptionRequested, error)

ParseRedemptionRequested is a log parse operation binding the contract event 0x7959c380174061a21a3ba80243a032ba9cd10dc8bd1736d7e835c94e97a35a98.

Solidity: event RedemptionRequested(address indexed _depositContractAddress, address indexed _requester, bytes32 indexed _digest, uint256 _utxoValue, bytes _redeemerOutputScript, uint256 _requestedFee, bytes _outpoint)

func (*DepositLogFilterer) ParseRegisteredPubkey 

func (_DepositLog *DepositLogFilterer) ParseRegisteredPubkey(log types.Log) (*DepositLogRegisteredPubkey, error)

ParseRegisteredPubkey is a log parse operation binding the contract event 0x8ee737ab16909c4e9d1b750814a4393c9f84ab5d3a29c08c313b783fc846ae33.

Solidity: event RegisteredPubkey(address indexed _depositContractAddress, bytes32 _signingGroupPubkeyX, bytes32 _signingGroupPubkeyY, uint256 _timestamp)

func (*DepositLogFilterer) ParseSetupFailed 

func (_DepositLog *DepositLogFilterer) ParseSetupFailed(log types.Log) (*DepositLogSetupFailed, error)

ParseSetupFailed is a log parse operation binding the contract event 0x8fd2cfb62a35fccc1ecef829f83a6c2f840b73dad49d3eaaa402909752086d4b.

Solidity: event SetupFailed(address indexed _depositContractAddress, uint256 _timestamp)

func (*DepositLogFilterer) ParseStartedLiquidation 

func (_DepositLog *DepositLogFilterer) ParseStartedLiquidation(log types.Log) (*DepositLogStartedLiquidation, error)

ParseStartedLiquidation is a log parse operation binding the contract event 0xbef11c059eefba82a15aea8a3a89c86fd08d7711c88fa7daea2632a55488510c.

Solidity: event StartedLiquidation(address indexed _depositContractAddress, bool _wasFraud, uint256 _timestamp)

func (*DepositLogFilterer) WatchCourtesyCalled 

func (_DepositLog *DepositLogFilterer) WatchCourtesyCalled(opts *bind.WatchOpts, sink chan<- *DepositLogCourtesyCalled, _depositContractAddress []common.Address) (event.Subscription, error)

WatchCourtesyCalled is a free log subscription operation binding the contract event 0x6e7b45210b79c12cd1332babd8d86c0bbb9ca898a89ce0404f17064dbfba18c0.

Solidity: event CourtesyCalled(address indexed _depositContractAddress, uint256 _timestamp)

func (*DepositLogFilterer) WatchCreated 

func (_DepositLog *DepositLogFilterer) WatchCreated(opts *bind.WatchOpts, sink chan<- *DepositLogCreated, _depositContractAddress []common.Address, _keepAddress []common.Address) (event.Subscription, error)

WatchCreated is a free log subscription operation binding the contract event 0x822b3073be62c5c7f143c2dcd71ee266434ee935d90a1eec3be34710ac8ec1a2.

Solidity: event Created(address indexed _depositContractAddress, address indexed _keepAddress, uint256 _timestamp)

func (*DepositLogFilterer) WatchExitedCourtesyCall 

func (_DepositLog *DepositLogFilterer) WatchExitedCourtesyCall(opts *bind.WatchOpts, sink chan<- *DepositLogExitedCourtesyCall, _depositContractAddress []common.Address) (event.Subscription, error)

WatchExitedCourtesyCall is a free log subscription operation binding the contract event 0x07f0eaafadb9abb1d28da85d4b4c74f1939fd61b535c7f5ab501f618f07e76ee.

Solidity: event ExitedCourtesyCall(address indexed _depositContractAddress, uint256 _timestamp)

func (*DepositLogFilterer) WatchFraudDuringSetup 

func (_DepositLog *DepositLogFilterer) WatchFraudDuringSetup(opts *bind.WatchOpts, sink chan<- *DepositLogFraudDuringSetup, _depositContractAddress []common.Address) (event.Subscription, error)

WatchFraudDuringSetup is a free log subscription operation binding the contract event 0x1e61af503f1d7de21d5300094c18bf8700f82b2951a4d54dd2adda13f6b3da30.

Solidity: event FraudDuringSetup(address indexed _depositContractAddress, uint256 _timestamp)

func (*DepositLogFilterer) WatchFunded 

func (_DepositLog *DepositLogFilterer) WatchFunded(opts *bind.WatchOpts, sink chan<- *DepositLogFunded, _depositContractAddress []common.Address, _txid [][32]byte) (event.Subscription, error)

WatchFunded is a free log subscription operation binding the contract event 0xe34c70bd3e03956978a5c76d2ea5f3a60819171afea6dee4fc12b2e45f72d43d.

Solidity: event Funded(address indexed _depositContractAddress, bytes32 indexed _txid, uint256 _timestamp)

func (*DepositLogFilterer) WatchFunderAbortRequested 

func (_DepositLog *DepositLogFilterer) WatchFunderAbortRequested(opts *bind.WatchOpts, sink chan<- *DepositLogFunderAbortRequested, _depositContractAddress []common.Address) (event.Subscription, error)

WatchFunderAbortRequested is a free log subscription operation binding the contract event 0xa6e9673b5d53b3fe3c62b6459720f9c2a1b129d4f69acb771404ba8681b6a930.

Solidity: event FunderAbortRequested(address indexed _depositContractAddress, bytes _abortOutputScript)

func (*DepositLogFilterer) WatchGotRedemptionSignature 

func (_DepositLog *DepositLogFilterer) WatchGotRedemptionSignature(opts *bind.WatchOpts, sink chan<- *DepositLogGotRedemptionSignature, _depositContractAddress []common.Address, _digest [][32]byte) (event.Subscription, error)

WatchGotRedemptionSignature is a free log subscription operation binding the contract event 0x7f7d7327762d01d2c4a552ea0be2bc5a76264574a80aa78083e691a840e509f2.

Solidity: event GotRedemptionSignature(address indexed _depositContractAddress, bytes32 indexed _digest, bytes32 _r, bytes32 _s, uint256 _timestamp)

func (*DepositLogFilterer) WatchLiquidated 

func (_DepositLog *DepositLogFilterer) WatchLiquidated(opts *bind.WatchOpts, sink chan<- *DepositLogLiquidated, _depositContractAddress []common.Address) (event.Subscription, error)

WatchLiquidated is a free log subscription operation binding the contract event 0xa5ee7a2b0254fce91deed604506790ed7fa072d0b14cba4859c3bc8955b9caac.

Solidity: event Liquidated(address indexed _depositContractAddress, uint256 _timestamp)

func (*DepositLogFilterer) WatchRedeemed 

func (_DepositLog *DepositLogFilterer) WatchRedeemed(opts *bind.WatchOpts, sink chan<- *DepositLogRedeemed, _depositContractAddress []common.Address, _txid [][32]byte) (event.Subscription, error)

WatchRedeemed is a free log subscription operation binding the contract event 0x44b7f176bcc739b54bd0800fe491cbdea19df7d4d6b19c281462e6b4fc504344.

Solidity: event Redeemed(address indexed _depositContractAddress, bytes32 indexed _txid, uint256 _timestamp)

func (*DepositLogFilterer) WatchRedemptionRequested 

func (_DepositLog *DepositLogFilterer) WatchRedemptionRequested(opts *bind.WatchOpts, sink chan<- *DepositLogRedemptionRequested, _depositContractAddress []common.Address, _requester []common.Address, _digest [][32]byte) (event.Subscription, error)

WatchRedemptionRequested is a free log subscription operation binding the contract event 0x7959c380174061a21a3ba80243a032ba9cd10dc8bd1736d7e835c94e97a35a98.

Solidity: event RedemptionRequested(address indexed _depositContractAddress, address indexed _requester, bytes32 indexed _digest, uint256 _utxoValue, bytes _redeemerOutputScript, uint256 _requestedFee, bytes _outpoint)

func (*DepositLogFilterer) WatchRegisteredPubkey 

func (_DepositLog *DepositLogFilterer) WatchRegisteredPubkey(opts *bind.WatchOpts, sink chan<- *DepositLogRegisteredPubkey, _depositContractAddress []common.Address) (event.Subscription, error)

WatchRegisteredPubkey is a free log subscription operation binding the contract event 0x8ee737ab16909c4e9d1b750814a4393c9f84ab5d3a29c08c313b783fc846ae33.

Solidity: event RegisteredPubkey(address indexed _depositContractAddress, bytes32 _signingGroupPubkeyX, bytes32 _signingGroupPubkeyY, uint256 _timestamp)

func (*DepositLogFilterer) WatchSetupFailed 

func (_DepositLog *DepositLogFilterer) WatchSetupFailed(opts *bind.WatchOpts, sink chan<- *DepositLogSetupFailed, _depositContractAddress []common.Address) (event.Subscription, error)

WatchSetupFailed is a free log subscription operation binding the contract event 0x8fd2cfb62a35fccc1ecef829f83a6c2f840b73dad49d3eaaa402909752086d4b.

Solidity: event SetupFailed(address indexed _depositContractAddress, uint256 _timestamp)

func (*DepositLogFilterer) WatchStartedLiquidation 

func (_DepositLog *DepositLogFilterer) WatchStartedLiquidation(opts *bind.WatchOpts, sink chan<- *DepositLogStartedLiquidation, _depositContractAddress []common.Address) (event.Subscription, error)

WatchStartedLiquidation is a free log subscription operation binding the contract event 0xbef11c059eefba82a15aea8a3a89c86fd08d7711c88fa7daea2632a55488510c.

Solidity: event StartedLiquidation(address indexed _depositContractAddress, bool _wasFraud, uint256 _timestamp)

type DepositLogFraudDuringSetup 

type DepositLogFraudDuringSetup struct {
	DepositContractAddress common.Address
	Timestamp              *big.Int
	Raw                    types.Log // Blockchain specific contextual infos
}

DepositLogFraudDuringSetup represents a FraudDuringSetup event raised by the DepositLog contract.

type DepositLogFraudDuringSetupIterator 

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

DepositLogFraudDuringSetupIterator is returned from FilterFraudDuringSetup and is used to iterate over the raw logs and unpacked data for FraudDuringSetup events raised by the DepositLog contract.

func (*DepositLogFraudDuringSetupIterator) Close 

func (it *DepositLogFraudDuringSetupIterator) Close() error

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

func (*DepositLogFraudDuringSetupIterator) Error 

func (it *DepositLogFraudDuringSetupIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DepositLogFraudDuringSetupIterator) Next 

func (it *DepositLogFraudDuringSetupIterator) 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 DepositLogFunded 

type DepositLogFunded struct {
	DepositContractAddress common.Address
	Txid                   [32]byte
	Timestamp              *big.Int
	Raw                    types.Log // Blockchain specific contextual infos
}

DepositLogFunded represents a Funded event raised by the DepositLog contract.

type DepositLogFundedIterator 

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

DepositLogFundedIterator is returned from FilterFunded and is used to iterate over the raw logs and unpacked data for Funded events raised by the DepositLog contract.

func (*DepositLogFundedIterator) Close 

func (it *DepositLogFundedIterator) Close() error

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

func (*DepositLogFundedIterator) Error 

func (it *DepositLogFundedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DepositLogFundedIterator) Next 

func (it *DepositLogFundedIterator) 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 DepositLogFunderAbortRequested 

type DepositLogFunderAbortRequested struct {
	DepositContractAddress common.Address
	AbortOutputScript      []byte
	Raw                    types.Log // Blockchain specific contextual infos
}

DepositLogFunderAbortRequested represents a FunderAbortRequested event raised by the DepositLog contract.

type DepositLogFunderAbortRequestedIterator 

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

DepositLogFunderAbortRequestedIterator is returned from FilterFunderAbortRequested and is used to iterate over the raw logs and unpacked data for FunderAbortRequested events raised by the DepositLog contract.

func (*DepositLogFunderAbortRequestedIterator) Close 

func (it *DepositLogFunderAbortRequestedIterator) Close() error

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

func (*DepositLogFunderAbortRequestedIterator) Error 

func (it *DepositLogFunderAbortRequestedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DepositLogFunderAbortRequestedIterator) Next 

func (it *DepositLogFunderAbortRequestedIterator) 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 DepositLogGotRedemptionSignature 

type DepositLogGotRedemptionSignature struct {
	DepositContractAddress common.Address
	Digest                 [32]byte
	R                      [32]byte
	S                      [32]byte
	Timestamp              *big.Int
	Raw                    types.Log // Blockchain specific contextual infos
}

DepositLogGotRedemptionSignature represents a GotRedemptionSignature event raised by the DepositLog contract.

type DepositLogGotRedemptionSignatureIterator 

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

DepositLogGotRedemptionSignatureIterator is returned from FilterGotRedemptionSignature and is used to iterate over the raw logs and unpacked data for GotRedemptionSignature events raised by the DepositLog contract.

func (*DepositLogGotRedemptionSignatureIterator) Close 

func (it *DepositLogGotRedemptionSignatureIterator) Close() error

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

func (*DepositLogGotRedemptionSignatureIterator) Error 

func (it *DepositLogGotRedemptionSignatureIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DepositLogGotRedemptionSignatureIterator) Next 

func (it *DepositLogGotRedemptionSignatureIterator) 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 DepositLogLiquidated 

type DepositLogLiquidated struct {
	DepositContractAddress common.Address
	Timestamp              *big.Int
	Raw                    types.Log // Blockchain specific contextual infos
}

DepositLogLiquidated represents a Liquidated event raised by the DepositLog contract.

type DepositLogLiquidatedIterator 

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

DepositLogLiquidatedIterator is returned from FilterLiquidated and is used to iterate over the raw logs and unpacked data for Liquidated events raised by the DepositLog contract.

func (*DepositLogLiquidatedIterator) Close 

func (it *DepositLogLiquidatedIterator) Close() error

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

func (*DepositLogLiquidatedIterator) Error 

func (it *DepositLogLiquidatedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DepositLogLiquidatedIterator) Next 

func (it *DepositLogLiquidatedIterator) 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 DepositLogRaw 

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

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

func (*DepositLogRaw) Call 

func (_DepositLog *DepositLogRaw) 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 (*DepositLogRaw) Transact 

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

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

func (*DepositLogRaw) Transfer 

func (_DepositLog *DepositLogRaw) 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 DepositLogRedeemed 

type DepositLogRedeemed struct {
	DepositContractAddress common.Address
	Txid                   [32]byte
	Timestamp              *big.Int
	Raw                    types.Log // Blockchain specific contextual infos
}

DepositLogRedeemed represents a Redeemed event raised by the DepositLog contract.

type DepositLogRedeemedIterator 

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

DepositLogRedeemedIterator is returned from FilterRedeemed and is used to iterate over the raw logs and unpacked data for Redeemed events raised by the DepositLog contract.

func (*DepositLogRedeemedIterator) Close 

func (it *DepositLogRedeemedIterator) Close() error

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

func (*DepositLogRedeemedIterator) Error 

func (it *DepositLogRedeemedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DepositLogRedeemedIterator) Next 

func (it *DepositLogRedeemedIterator) 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 DepositLogRedemptionRequested 

type DepositLogRedemptionRequested struct {
	DepositContractAddress common.Address
	Requester              common.Address
	Digest                 [32]byte
	UtxoValue              *big.Int
	RedeemerOutputScript   []byte
	RequestedFee           *big.Int
	Outpoint               []byte
	Raw                    types.Log // Blockchain specific contextual infos
}

DepositLogRedemptionRequested represents a RedemptionRequested event raised by the DepositLog contract.

type DepositLogRedemptionRequestedIterator 

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

DepositLogRedemptionRequestedIterator is returned from FilterRedemptionRequested and is used to iterate over the raw logs and unpacked data for RedemptionRequested events raised by the DepositLog contract.

func (*DepositLogRedemptionRequestedIterator) Close 

func (it *DepositLogRedemptionRequestedIterator) Close() error

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

func (*DepositLogRedemptionRequestedIterator) Error 

func (it *DepositLogRedemptionRequestedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DepositLogRedemptionRequestedIterator) Next 

func (it *DepositLogRedemptionRequestedIterator) 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 DepositLogRegisteredPubkey 

type DepositLogRegisteredPubkey struct {
	DepositContractAddress common.Address
	SigningGroupPubkeyX    [32]byte
	SigningGroupPubkeyY    [32]byte
	Timestamp              *big.Int
	Raw                    types.Log // Blockchain specific contextual infos
}

DepositLogRegisteredPubkey represents a RegisteredPubkey event raised by the DepositLog contract.

type DepositLogRegisteredPubkeyIterator 

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

DepositLogRegisteredPubkeyIterator is returned from FilterRegisteredPubkey and is used to iterate over the raw logs and unpacked data for RegisteredPubkey events raised by the DepositLog contract.

func (*DepositLogRegisteredPubkeyIterator) Close 

func (it *DepositLogRegisteredPubkeyIterator) Close() error

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

func (*DepositLogRegisteredPubkeyIterator) Error 

func (it *DepositLogRegisteredPubkeyIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DepositLogRegisteredPubkeyIterator) Next 

func (it *DepositLogRegisteredPubkeyIterator) 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 DepositLogSession 

type DepositLogSession struct {
	Contract     *DepositLog       // 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
}

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

func (*DepositLogSession) ApprovedToLog 

func (_DepositLog *DepositLogSession) ApprovedToLog(_caller common.Address) (bool, error)

ApprovedToLog is a free data retrieval call binding the contract method 0x9ffb3862.

Solidity: function approvedToLog(address _caller) constant returns(bool)

func (*DepositLogSession) LogCourtesyCalled 

func (_DepositLog *DepositLogSession) LogCourtesyCalled() (*types.Transaction, error)

LogCourtesyCalled is a paid mutator transaction binding the contract method 0x22a147e6.

Solidity: function logCourtesyCalled() returns()

func (*DepositLogSession) LogCreated 

func (_DepositLog *DepositLogSession) LogCreated(_keepAddress common.Address) (*types.Transaction, error)

LogCreated is a paid mutator transaction binding the contract method 0x282bfd38.

Solidity: function logCreated(address _keepAddress) returns()

func (*DepositLogSession) LogExitedCourtesyCall 

func (_DepositLog *DepositLogSession) LogExitedCourtesyCall() (*types.Transaction, error)

LogExitedCourtesyCall is a paid mutator transaction binding the contract method 0x22e5724c.

Solidity: function logExitedCourtesyCall() returns()

func (*DepositLogSession) LogFraudDuringSetup 

func (_DepositLog *DepositLogSession) LogFraudDuringSetup() (*types.Transaction, error)

LogFraudDuringSetup is a paid mutator transaction binding the contract method 0xe2c50ad8.

Solidity: function logFraudDuringSetup() returns()

func (*DepositLogSession) LogFunded 

func (_DepositLog *DepositLogSession) LogFunded(_txid [32]byte) (*types.Transaction, error)

LogFunded is a paid mutator transaction binding the contract method 0x7ed451a4.

Solidity: function logFunded(bytes32 _txid) returns()

func (*DepositLogSession) LogFunderRequestedAbort 

func (_DepositLog *DepositLogSession) LogFunderRequestedAbort(_abortOutputScript []byte) (*types.Transaction, error)

LogFunderRequestedAbort is a paid mutator transaction binding the contract method 0xce2c07ce.

Solidity: function logFunderRequestedAbort(bytes _abortOutputScript) returns()

func (*DepositLogSession) LogGotRedemptionSignature 

func (_DepositLog *DepositLogSession) LogGotRedemptionSignature(_digest [32]byte, _r [32]byte, _s [32]byte) (*types.Transaction, error)

LogGotRedemptionSignature is a paid mutator transaction binding the contract method 0xf760621e.

Solidity: function logGotRedemptionSignature(bytes32 _digest, bytes32 _r, bytes32 _s) returns()

func (*DepositLogSession) LogLiquidated 

func (_DepositLog *DepositLogSession) LogLiquidated() (*types.Transaction, error)

LogLiquidated is a paid mutator transaction binding the contract method 0xc8fba243.

Solidity: function logLiquidated() returns()

func (*DepositLogSession) LogRedeemed 

func (_DepositLog *DepositLogSession) LogRedeemed(_txid [32]byte) (*types.Transaction, error)

LogRedeemed is a paid mutator transaction binding the contract method 0x6e1ba283.

Solidity: function logRedeemed(bytes32 _txid) returns()

func (*DepositLogSession) LogRedemptionRequested 

func (_DepositLog *DepositLogSession) LogRedemptionRequested(_requester common.Address, _digest [32]byte, _utxoValue *big.Int, _redeemerOutputScript []byte, _requestedFee *big.Int, _outpoint []byte) (*types.Transaction, error)

LogRedemptionRequested is a paid mutator transaction binding the contract method 0x18e647dd.

Solidity: function logRedemptionRequested(address _requester, bytes32 _digest, uint256 _utxoValue, bytes _redeemerOutputScript, uint256 _requestedFee, bytes _outpoint) returns()

func (*DepositLogSession) LogRegisteredPubkey 

func (_DepositLog *DepositLogSession) LogRegisteredPubkey(_signingGroupPubkeyX [32]byte, _signingGroupPubkeyY [32]byte) (*types.Transaction, error)

LogRegisteredPubkey is a paid mutator transaction binding the contract method 0x869f9469.

Solidity: function logRegisteredPubkey(bytes32 _signingGroupPubkeyX, bytes32 _signingGroupPubkeyY) returns()

func (*DepositLogSession) LogSetupFailed 

func (_DepositLog *DepositLogSession) LogSetupFailed() (*types.Transaction, error)

LogSetupFailed is a paid mutator transaction binding the contract method 0xa831c816.

Solidity: function logSetupFailed() returns()

func (*DepositLogSession) LogStartedLiquidation 

func (_DepositLog *DepositLogSession) LogStartedLiquidation(_wasFraud bool) (*types.Transaction, error)

LogStartedLiquidation is a paid mutator transaction binding the contract method 0x3aac3467.

Solidity: function logStartedLiquidation(bool _wasFraud) returns()

type DepositLogSetupFailed 

type DepositLogSetupFailed struct {
	DepositContractAddress common.Address
	Timestamp              *big.Int
	Raw                    types.Log // Blockchain specific contextual infos
}

DepositLogSetupFailed represents a SetupFailed event raised by the DepositLog contract.

type DepositLogSetupFailedIterator 

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

DepositLogSetupFailedIterator is returned from FilterSetupFailed and is used to iterate over the raw logs and unpacked data for SetupFailed events raised by the DepositLog contract.

func (*DepositLogSetupFailedIterator) Close 

func (it *DepositLogSetupFailedIterator) Close() error

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

func (*DepositLogSetupFailedIterator) Error 

func (it *DepositLogSetupFailedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DepositLogSetupFailedIterator) Next 

func (it *DepositLogSetupFailedIterator) 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 DepositLogStartedLiquidation 

type DepositLogStartedLiquidation struct {
	DepositContractAddress common.Address
	WasFraud               bool
	Timestamp              *big.Int
	Raw                    types.Log // Blockchain specific contextual infos
}

DepositLogStartedLiquidation represents a StartedLiquidation event raised by the DepositLog contract.

type DepositLogStartedLiquidationIterator 

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

DepositLogStartedLiquidationIterator is returned from FilterStartedLiquidation and is used to iterate over the raw logs and unpacked data for StartedLiquidation events raised by the DepositLog contract.

func (*DepositLogStartedLiquidationIterator) Close 

func (it *DepositLogStartedLiquidationIterator) Close() error

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

func (*DepositLogStartedLiquidationIterator) Error 

func (it *DepositLogStartedLiquidationIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DepositLogStartedLiquidationIterator) Next 

func (it *DepositLogStartedLiquidationIterator) 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 DepositLogTransactor 

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

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

func NewDepositLogTransactor 

func NewDepositLogTransactor(address common.Address, transactor bind.ContractTransactor) (*DepositLogTransactor, error)

NewDepositLogTransactor creates a new write-only instance of DepositLog, bound to a specific deployed contract.

func (*DepositLogTransactor) LogCourtesyCalled 

func (_DepositLog *DepositLogTransactor) LogCourtesyCalled(opts *bind.TransactOpts) (*types.Transaction, error)

LogCourtesyCalled is a paid mutator transaction binding the contract method 0x22a147e6.

Solidity: function logCourtesyCalled() returns()

func (*DepositLogTransactor) LogCreated 

func (_DepositLog *DepositLogTransactor) LogCreated(opts *bind.TransactOpts, _keepAddress common.Address) (*types.Transaction, error)

LogCreated is a paid mutator transaction binding the contract method 0x282bfd38.

Solidity: function logCreated(address _keepAddress) returns()

func (*DepositLogTransactor) LogExitedCourtesyCall 

func (_DepositLog *DepositLogTransactor) LogExitedCourtesyCall(opts *bind.TransactOpts) (*types.Transaction, error)

LogExitedCourtesyCall is a paid mutator transaction binding the contract method 0x22e5724c.

Solidity: function logExitedCourtesyCall() returns()

func (*DepositLogTransactor) LogFraudDuringSetup 

func (_DepositLog *DepositLogTransactor) LogFraudDuringSetup(opts *bind.TransactOpts) (*types.Transaction, error)

LogFraudDuringSetup is a paid mutator transaction binding the contract method 0xe2c50ad8.

Solidity: function logFraudDuringSetup() returns()

func (*DepositLogTransactor) LogFunded 

func (_DepositLog *DepositLogTransactor) LogFunded(opts *bind.TransactOpts, _txid [32]byte) (*types.Transaction, error)

LogFunded is a paid mutator transaction binding the contract method 0x7ed451a4.

Solidity: function logFunded(bytes32 _txid) returns()

func (*DepositLogTransactor) LogFunderRequestedAbort 

func (_DepositLog *DepositLogTransactor) LogFunderRequestedAbort(opts *bind.TransactOpts, _abortOutputScript []byte) (*types.Transaction, error)

LogFunderRequestedAbort is a paid mutator transaction binding the contract method 0xce2c07ce.

Solidity: function logFunderRequestedAbort(bytes _abortOutputScript) returns()

func (*DepositLogTransactor) LogGotRedemptionSignature 

func (_DepositLog *DepositLogTransactor) LogGotRedemptionSignature(opts *bind.TransactOpts, _digest [32]byte, _r [32]byte, _s [32]byte) (*types.Transaction, error)

LogGotRedemptionSignature is a paid mutator transaction binding the contract method 0xf760621e.

Solidity: function logGotRedemptionSignature(bytes32 _digest, bytes32 _r, bytes32 _s) returns()

func (*DepositLogTransactor) LogLiquidated 

func (_DepositLog *DepositLogTransactor) LogLiquidated(opts *bind.TransactOpts) (*types.Transaction, error)

LogLiquidated is a paid mutator transaction binding the contract method 0xc8fba243.

Solidity: function logLiquidated() returns()

func (*DepositLogTransactor) LogRedeemed 

func (_DepositLog *DepositLogTransactor) LogRedeemed(opts *bind.TransactOpts, _txid [32]byte) (*types.Transaction, error)

LogRedeemed is a paid mutator transaction binding the contract method 0x6e1ba283.

Solidity: function logRedeemed(bytes32 _txid) returns()

func (*DepositLogTransactor) LogRedemptionRequested 

func (_DepositLog *DepositLogTransactor) LogRedemptionRequested(opts *bind.TransactOpts, _requester common.Address, _digest [32]byte, _utxoValue *big.Int, _redeemerOutputScript []byte, _requestedFee *big.Int, _outpoint []byte) (*types.Transaction, error)

LogRedemptionRequested is a paid mutator transaction binding the contract method 0x18e647dd.

Solidity: function logRedemptionRequested(address _requester, bytes32 _digest, uint256 _utxoValue, bytes _redeemerOutputScript, uint256 _requestedFee, bytes _outpoint) returns()

func (*DepositLogTransactor) LogRegisteredPubkey 

func (_DepositLog *DepositLogTransactor) LogRegisteredPubkey(opts *bind.TransactOpts, _signingGroupPubkeyX [32]byte, _signingGroupPubkeyY [32]byte) (*types.Transaction, error)

LogRegisteredPubkey is a paid mutator transaction binding the contract method 0x869f9469.

Solidity: function logRegisteredPubkey(bytes32 _signingGroupPubkeyX, bytes32 _signingGroupPubkeyY) returns()

func (*DepositLogTransactor) LogSetupFailed 

func (_DepositLog *DepositLogTransactor) LogSetupFailed(opts *bind.TransactOpts) (*types.Transaction, error)

LogSetupFailed is a paid mutator transaction binding the contract method 0xa831c816.

Solidity: function logSetupFailed() returns()

func (*DepositLogTransactor) LogStartedLiquidation 

func (_DepositLog *DepositLogTransactor) LogStartedLiquidation(opts *bind.TransactOpts, _wasFraud bool) (*types.Transaction, error)

LogStartedLiquidation is a paid mutator transaction binding the contract method 0x3aac3467.

Solidity: function logStartedLiquidation(bool _wasFraud) returns()

type DepositLogTransactorRaw 

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

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

func (*DepositLogTransactorRaw) Transact 

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

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

func (*DepositLogTransactorRaw) Transfer 

func (_DepositLog *DepositLogTransactorRaw) 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 DepositLogTransactorSession 

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

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

func (*DepositLogTransactorSession) LogCourtesyCalled 

func (_DepositLog *DepositLogTransactorSession) LogCourtesyCalled() (*types.Transaction, error)

LogCourtesyCalled is a paid mutator transaction binding the contract method 0x22a147e6.

Solidity: function logCourtesyCalled() returns()

func (*DepositLogTransactorSession) LogCreated 

func (_DepositLog *DepositLogTransactorSession) LogCreated(_keepAddress common.Address) (*types.Transaction, error)

LogCreated is a paid mutator transaction binding the contract method 0x282bfd38.

Solidity: function logCreated(address _keepAddress) returns()

func (*DepositLogTransactorSession) LogExitedCourtesyCall 

func (_DepositLog *DepositLogTransactorSession) LogExitedCourtesyCall() (*types.Transaction, error)

LogExitedCourtesyCall is a paid mutator transaction binding the contract method 0x22e5724c.

Solidity: function logExitedCourtesyCall() returns()

func (*DepositLogTransactorSession) LogFraudDuringSetup 

func (_DepositLog *DepositLogTransactorSession) LogFraudDuringSetup() (*types.Transaction, error)

LogFraudDuringSetup is a paid mutator transaction binding the contract method 0xe2c50ad8.

Solidity: function logFraudDuringSetup() returns()

func (*DepositLogTransactorSession) LogFunded 

func (_DepositLog *DepositLogTransactorSession) LogFunded(_txid [32]byte) (*types.Transaction, error)

LogFunded is a paid mutator transaction binding the contract method 0x7ed451a4.

Solidity: function logFunded(bytes32 _txid) returns()

func (*DepositLogTransactorSession) LogFunderRequestedAbort 

func (_DepositLog *DepositLogTransactorSession) LogFunderRequestedAbort(_abortOutputScript []byte) (*types.Transaction, error)

LogFunderRequestedAbort is a paid mutator transaction binding the contract method 0xce2c07ce.

Solidity: function logFunderRequestedAbort(bytes _abortOutputScript) returns()

func (*DepositLogTransactorSession) LogGotRedemptionSignature 

func (_DepositLog *DepositLogTransactorSession) LogGotRedemptionSignature(_digest [32]byte, _r [32]byte, _s [32]byte) (*types.Transaction, error)

LogGotRedemptionSignature is a paid mutator transaction binding the contract method 0xf760621e.

Solidity: function logGotRedemptionSignature(bytes32 _digest, bytes32 _r, bytes32 _s) returns()

func (*DepositLogTransactorSession) LogLiquidated 

func (_DepositLog *DepositLogTransactorSession) LogLiquidated() (*types.Transaction, error)

LogLiquidated is a paid mutator transaction binding the contract method 0xc8fba243.

Solidity: function logLiquidated() returns()

func (*DepositLogTransactorSession) LogRedeemed 

func (_DepositLog *DepositLogTransactorSession) LogRedeemed(_txid [32]byte) (*types.Transaction, error)

LogRedeemed is a paid mutator transaction binding the contract method 0x6e1ba283.

Solidity: function logRedeemed(bytes32 _txid) returns()

func (*DepositLogTransactorSession) LogRedemptionRequested 

func (_DepositLog *DepositLogTransactorSession) LogRedemptionRequested(_requester common.Address, _digest [32]byte, _utxoValue *big.Int, _redeemerOutputScript []byte, _requestedFee *big.Int, _outpoint []byte) (*types.Transaction, error)

LogRedemptionRequested is a paid mutator transaction binding the contract method 0x18e647dd.

Solidity: function logRedemptionRequested(address _requester, bytes32 _digest, uint256 _utxoValue, bytes _redeemerOutputScript, uint256 _requestedFee, bytes _outpoint) returns()

func (*DepositLogTransactorSession) LogRegisteredPubkey 

func (_DepositLog *DepositLogTransactorSession) LogRegisteredPubkey(_signingGroupPubkeyX [32]byte, _signingGroupPubkeyY [32]byte) (*types.Transaction, error)

LogRegisteredPubkey is a paid mutator transaction binding the contract method 0x869f9469.

Solidity: function logRegisteredPubkey(bytes32 _signingGroupPubkeyX, bytes32 _signingGroupPubkeyY) returns()

func (*DepositLogTransactorSession) LogSetupFailed 

func (_DepositLog *DepositLogTransactorSession) LogSetupFailed() (*types.Transaction, error)

LogSetupFailed is a paid mutator transaction binding the contract method 0xa831c816.

Solidity: function logSetupFailed() returns()

func (*DepositLogTransactorSession) LogStartedLiquidation 

func (_DepositLog *DepositLogTransactorSession) LogStartedLiquidation(_wasFraud bool) (*types.Transaction, error)

LogStartedLiquidation is a paid mutator transaction binding the contract method 0x3aac3467.

Solidity: function logStartedLiquidation(bool _wasFraud) returns()

Source Files

View all Source files

Directories

Path Synopsis

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.