import type { Observable } from 'rxjs';
import type { RaidenAction } from '../../actions';
import { messageSend } from '../../messages/actions';
import type { RaidenState } from '../../state';
import type { RaidenEpicDeps } from '../../types';
import { transfer, transferSecret, transferSecretRegister, transferSecretRequest, transferSecretReveal, transferUnlock } from '../actions';
/**
 * Handles receiving a signed SecretRequest from target for some sent LockedTransfer
 * Emits a transferSecretRequest action only if all conditions are met
 *
 * @param action$ - Observable of messageReceived actions
 * @param state$ - Observable of RaidenStates
 * @param deps - Epics dependencies
 * @param deps.address - Our address
 * @param deps.log - Logger instance
 * @returns Observable of transferSecretRequest actions
 */
export declare function transferSecretRequestedEpic(action$: Observable<RaidenAction>, state$: Observable<RaidenState>, { address, log }: RaidenEpicDeps): Observable<transferSecretRequest>;
/**
 * Handles a transferSecretRequest action to send the respective secret to target
 * It both emits transferSecretReveal (to persist sent SecretReveal in state and indicate that
 * the secret was revealed and thus the transfer should be assumed as succeeded) as well as
 * triggers sending the message once. New SecretRequests will cause a new transferSecretRequest,
 * which will re-send the cached SecretReveal.
 * transfer.failure is emitted in case invalid secretRequest comes, as no valid one will come as
 * per current implementation, so we fail early to notify users about it.
 *
 * @param action$ - Observable of transferSecretRequest actions
 * @param state$ - Observable of RaidenStates
 * @param deps - RaidenEpicDeps
 * @param deps.signer - Signer instance
 * @param deps.latest$ - Latest observable
 * @param deps.log - Logger instance
 * @returns Observable of transfer.failure|transferSecretReveal|messageSend.request actions
 */
export declare function transferSecretRevealEpic(action$: Observable<RaidenAction>, {}: Observable<RaidenState>, deps: RaidenEpicDeps): Observable<transfer.failure | transferSecretReveal | messageSend.request>;
/**
 * Handles receiving a valid SecretReveal from recipient (neighbor/partner)
 * This indicates that the partner knowws the secret, and we should Unlock to avoid going on-chain.
 * The transferUnlock.request action is a request for the unlocking to be generated and sent.
 *
 * @param action$ - Observable of RaidenActions
 * @param state$ - Observable of RaidenStates
 * @param deps - Epics dependencies
 * @param deps.config$ - Config observable
 * @returns Observable of output actions for this epic
 */
export declare function transferSecretRevealedEpic(action$: Observable<RaidenAction>, state$: Observable<RaidenState>, { config$ }: RaidenEpicDeps): Observable<transferUnlock.request | transferSecret>;
/**
 * For a received transfer, when we know the secret, sign & send a SecretReveal to previous hop
 *
 * @param action$ - Observable of transferSecret|transferSecretReveal actions
 * @param state$ - Observable of RaidenStates
 * @param deps - RaidenEpicDeps
 * @param deps.log - Logger instance
 * @param deps.signer - Signer instance
 * @param deps.latest$ - Latest observable
 * @returns Observable of transferSecretReveal actions
 */
export declare function transferRequestUnlockEpic(action$: Observable<RaidenAction>, {}: Observable<RaidenState>, { log, signer, latest$ }: RaidenEpicDeps): Observable<transferSecretReveal>;
/**
 * Monitors SecretRegistry and emits when a relevant secret gets registered
 *
 * @param action$ - Observable of RaidenActions
 * @param state$ - Observable of RaidenStates
 * @param deps - Epics dependencies
 * @param deps.provider - Provider instance
 * @param deps.secretRegistryContract - SecretRegistry contract instance
 * @param deps.config$ - Config observable
 * @param deps.init$ - Init$ tasks subject
 * @param deps.getBlockTimestamp - block timestamp getter function
 * @returns Observable of transferSecretRegister.success actions
 */
export declare function monitorSecretRegistryEpic({}: Observable<RaidenAction>, state$: Observable<RaidenState>, { provider, secretRegistryContract, config$, init$, getBlockTimestamp }: RaidenEpicDeps): Observable<transferSecretRegister.success>;
/**
 * A simple epic to emit transfer.success when secret register is confirmed
 *
 * @param action$ - Observable of transferSecretRegister.success actions
 * @returns Observable of transfer.success actions
 */
export declare function transferSuccessOnSecretRegisteredEpic(action$: Observable<RaidenAction>): Observable<transfer.success>;
/**
 * Process newBlocks and pending received transfers. If we know the secret, and transfer doesn't
 * get unlocked before revealTimeout seconds are left to lock expiration, request to register secret
 * TODO: check economic viability (and define what that means) of registering lock on-chain
 *
 * @param action$ - Observable of newBlock actions
 * @param state$ - Observable of RaidenStates
 * @param deps - Epics dependencies
 * @param deps.config$ - Config observable
 * @returns Observable of transferSecretRegister.request actions
 */
export declare function transferAutoRegisterEpic(action$: Observable<RaidenAction>, state$: Observable<RaidenState>, { config$ }: RaidenEpicDeps): Observable<transferSecretRegister.request>;
/**
 * Registers secret on-chain. Success is detected by monitorSecretRegistryEpic
 *
 * @param action$ - Observable of transferSecretRegister.request actions
 * @param state$ - Observable of RaidenStates
 * @param deps - Epics dependencies
 * @returns Observable of transferSecretRegister.failure actions
 */
export declare function transferSecretRegisterEpic(action$: Observable<RaidenAction>, {}: Observable<RaidenState>, deps: RaidenEpicDeps): Observable<transferSecretRegister.failure>;