raiden-ts/dist:cjs/transfers/actions.d.ts

Raiden Light Client Typescript/Javascript SDK

import * as t from 'io-ts';
import { BalanceProof } from '../channels/types';
import { LockedTransfer, LockExpired, Processed, SecretRequest, SecretReveal, Unlock, WithdrawConfirmation, WithdrawExpired, WithdrawRequest } from '../messages/types';
import type { ActionType } from '../utils/actions';
import { Address, UInt } from '../utils/types';
import { TransferState } from './state';
/**
 * A transfer async action set
 *
 * A transfer is considered as having succeeded from the time the secret is revealed to the target,
 * as from there, target and mediators can claim the payment down to us. But the full off-chain
 * happy case completes only after partner/neighbor acknowledges receiving the Unlock.
 * So, we usually only emits this action in the end of the happy case, and it'll then contain the
 * unlock's balanceProof, which indicates the full off-chain path succeeded.
 * It'll be emitted without a balanceProof if something forces the transfer to complete
 * (e.g.  channel closed), the secret was revealed (so target was paid) but for any reason the
 * unlock didn't happen yet.
 *
 * transfer.failure is emitted as soon as we know the transfer failed definitely, like when a
 * RefundTransfer is received or the lock expires before revealing the secret. It notifies the user
 * (e.g. pending Promises) that the transfer failed and won't be paid (eventually, locked amount
 * will be recovered by expiring the lock).
 */
export declare const transfer: {
    readonly request: ((payload: {
        tokenNetwork: Address;
        target: Address;
        value: UInt<32>;
        paymentId: UInt<8>;
    } & (({
        resolved: false;
    } & {
        paths?: readonly Readonly<({
            route: readonly Address[];
        } | {
            path: readonly Address[];
        }) & ({
            fee: import("../utils/types").Int<32>;
        } | {
            estimated_fee: import("../utils/types").Int<32>;
        }) & {
            address_metadata?: Readonly<{
                [x: string]: import("../services/types").AddressMetadata;
            }> | undefined;
        }>[] | undefined;
        pfs?: Readonly<{
            address: Address;
            url: string;
            matrixServer: string;
            rtt: number;
            price: UInt<32>;
            token: Address;
            validTill: number;
        }> | null | undefined;
        encryptSecret?: boolean | undefined;
    }) | ({
        resolved: true;
        metadata: unknown;
        fee: import("../utils/types").Int<32>;
        partner: Address;
    } & {
        userId?: string | undefined;
    })) & {
        secret?: import("../utils/types").HexString<32> | undefined;
        initiator?: Address | undefined;
    } & ({
        expiration?: number | undefined;
    } | {
        lockTimeout?: number | undefined;
    }), meta: {
        secrethash: import("../utils/types").HexString<32>;
        direction: import("./state").Direction;
    }) => {
        readonly type: "transfer/request";
        readonly payload: {
            tokenNetwork: Address;
            target: Address;
            value: UInt<32>;
            paymentId: UInt<8>;
        } & (({
            resolved: false;
        } & {
            paths?: readonly Readonly<({
                route: readonly Address[];
            } | {
                path: readonly Address[];
            }) & ({
                fee: import("../utils/types").Int<32>;
            } | {
                estimated_fee: import("../utils/types").Int<32>;
            }) & {
                address_metadata?: Readonly<{
                    [x: string]: import("../services/types").AddressMetadata;
                }> | undefined;
            }>[] | undefined;
            pfs?: Readonly<{
                address: Address;
                url: string;
                matrixServer: string;
                rtt: number;
                price: UInt<32>;
                token: Address;
                validTill: number;
            }> | null | undefined;
            encryptSecret?: boolean | undefined;
        }) | ({
            resolved: true;
            metadata: unknown;
            fee: import("../utils/types").Int<32>;
            partner: Address;
        } & {
            userId?: string | undefined;
        })) & {
            secret?: import("../utils/types").HexString<32> | undefined;
            initiator?: Address | undefined;
        } & ({
            expiration?: number | undefined;
        } | {
            lockTimeout?: number | undefined;
        });
        readonly meta: {
            secrethash: import("../utils/types").HexString<32>;
            direction: import("./state").Direction;
        };
    }) & {
        type: "transfer/request";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "transfer/request";
            readonly payload: {
                tokenNetwork: Address;
                target: Address;
                value: UInt<32>;
                paymentId: UInt<8>;
            } & (({
                resolved: false;
            } & {
                paths?: readonly Readonly<({
                    route: readonly Address[];
                } | {
                    path: readonly Address[];
                }) & ({
                    fee: import("../utils/types").Int<32>;
                } | {
                    estimated_fee: import("../utils/types").Int<32>;
                }) & {
                    address_metadata?: Readonly<{
                        [x: string]: import("../services/types").AddressMetadata;
                    }> | undefined;
                }>[] | undefined;
                pfs?: Readonly<{
                    address: Address;
                    url: string;
                    matrixServer: string;
                    rtt: number;
                    price: UInt<32>;
                    token: Address;
                    validTill: number;
                }> | null | undefined;
                encryptSecret?: boolean | undefined;
            }) | ({
                resolved: true;
                metadata: unknown;
                fee: import("../utils/types").Int<32>;
                partner: Address;
            } & {
                userId?: string | undefined;
            })) & {
                secret?: import("../utils/types").HexString<32> | undefined;
                initiator?: Address | undefined;
            } & ({
                expiration?: number | undefined;
            } | {
                lockTimeout?: number | undefined;
            });
            readonly meta: {
                secrethash: import("../utils/types").HexString<32>;
                direction: import("./state").Direction;
            };
        };
        error: undefined;
    };
    /** Partner acknowledge they received and processed our LockExpired */
    readonly success: ((payload: {
        balanceProof?: (BalanceProof & Readonly<{
            signature: import("../utils/types").HexString<65>;
        }>) | undefined;
    }, meta: {
        secrethash: import("../utils/types").HexString<32>;
        direction: import("./state").Direction;
    }) => {
        readonly type: "transfer/success";
        readonly payload: {
            balanceProof?: (BalanceProof & Readonly<{
                signature: import("../utils/types").HexString<65>;
            }>) | undefined;
        };
        readonly meta: {
            secrethash: import("../utils/types").HexString<32>;
            direction: import("./state").Direction;
        };
    }) & {
        type: "transfer/success";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "transfer/success";
            readonly payload: {
                balanceProof?: (BalanceProof & Readonly<{
                    signature: import("../utils/types").HexString<65>;
                }>) | undefined;
            };
            readonly meta: {
                secrethash: import("../utils/types").HexString<32>;
                direction: import("./state").Direction;
            };
        };
        error: undefined;
    };
    readonly failure: ((payload: unknown, meta: {
        secrethash: import("../utils/types").HexString<32>;
        direction: import("./state").Direction;
    }) => {
        readonly type: "transfer/failure";
        readonly payload: unknown;
        readonly meta: {
            secrethash: import("../utils/types").HexString<32>;
            direction: import("./state").Direction;
        };
        readonly error: true;
    }) & {
        type: "transfer/failure";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "transfer/failure";
            readonly payload: unknown;
            readonly meta: {
                secrethash: import("../utils/types").HexString<32>;
                direction: import("./state").Direction;
            };
            readonly error: true;
        };
        error: true;
    };
};
export declare namespace transfer {
    interface request extends ActionType<typeof transfer.request> {
    }
    interface success extends ActionType<typeof transfer.success> {
    }
    interface failure extends ActionType<typeof transfer.failure> {
    }
}
/** A LockedTransfer was signed and should be sent to partner */
export declare const transferSigned: ((payload: {
    message: LockedTransfer & Readonly<{
        signature: import("../utils/types").HexString<65>;
    }>;
    fee: import("../utils/types").Int<32>;
    partner: Address;
} & {
    userId?: string | undefined;
}, meta: {
    secrethash: import("../utils/types").HexString<32>;
    direction: import("./state").Direction;
}) => {
    readonly type: "transfer/signed";
    readonly payload: {
        message: LockedTransfer & Readonly<{
            signature: import("../utils/types").HexString<65>;
        }>;
        fee: import("../utils/types").Int<32>;
        partner: Address;
    } & {
        userId?: string | undefined;
    };
    readonly meta: {
        secrethash: import("../utils/types").HexString<32>;
        direction: import("./state").Direction;
    };
}) & {
    type: "transfer/signed";
    codec: t.Mixed;
    is: (a: unknown) => a is {
        readonly type: "transfer/signed";
        readonly payload: {
            message: LockedTransfer & Readonly<{
                signature: import("../utils/types").HexString<65>;
            }>;
            fee: import("../utils/types").Int<32>;
            partner: Address;
        } & {
            userId?: string | undefined;
        };
        readonly meta: {
            secrethash: import("../utils/types").HexString<32>;
            direction: import("./state").Direction;
        };
    };
    error: undefined;
};
export interface transferSigned extends ActionType<typeof transferSigned> {
}
/** Partner acknowledge they received and processed our LockedTransfer */
export declare const transferProcessed: ((payload: {
    message: Processed & Readonly<{
        signature: import("../utils/types").HexString<65>;
    }>;
} & {
    userId?: string | undefined;
}, meta: {
    secrethash: import("../utils/types").HexString<32>;
    direction: import("./state").Direction;
}) => {
    readonly type: "transfer/processed";
    readonly payload: {
        message: Processed & Readonly<{
            signature: import("../utils/types").HexString<65>;
        }>;
    } & {
        userId?: string | undefined;
    };
    readonly meta: {
        secrethash: import("../utils/types").HexString<32>;
        direction: import("./state").Direction;
    };
}) & {
    type: "transfer/processed";
    codec: t.Mixed;
    is: (a: unknown) => a is {
        readonly type: "transfer/processed";
        readonly payload: {
            message: Processed & Readonly<{
                signature: import("../utils/types").HexString<65>;
            }>;
        } & {
            userId?: string | undefined;
        };
        readonly meta: {
            secrethash: import("../utils/types").HexString<32>;
            direction: import("./state").Direction;
        };
    };
    error: undefined;
};
export interface transferProcessed extends ActionType<typeof transferProcessed> {
}
/** Register a secret */
export declare const transferSecret: ((payload: {
    secret: import("../utils/types").HexString<32>;
}, meta: {
    secrethash: import("../utils/types").HexString<32>;
    direction: import("./state").Direction;
}) => {
    readonly type: "transfer/secret";
    readonly payload: {
        secret: import("../utils/types").HexString<32>;
    };
    readonly meta: {
        secrethash: import("../utils/types").HexString<32>;
        direction: import("./state").Direction;
    };
}) & {
    type: "transfer/secret";
    codec: t.Mixed;
    is: (a: unknown) => a is {
        readonly type: "transfer/secret";
        readonly payload: {
            secret: import("../utils/types").HexString<32>;
        };
        readonly meta: {
            secrethash: import("../utils/types").HexString<32>;
            direction: import("./state").Direction;
        };
    };
    error: undefined;
};
export interface transferSecret extends ActionType<typeof transferSecret> {
}
export declare const transferSecretRegister: {
    readonly request: ((payload: {
        secret: import("../utils/types").HexString<32>;
    }, meta: {
        secrethash: import("../utils/types").HexString<32>;
        direction: import("./state").Direction;
    }) => {
        readonly type: "transfer/secret/register/request";
        readonly payload: {
            secret: import("../utils/types").HexString<32>;
        };
        readonly meta: {
            secrethash: import("../utils/types").HexString<32>;
            direction: import("./state").Direction;
        };
    }) & {
        type: "transfer/secret/register/request";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "transfer/secret/register/request";
            readonly payload: {
                secret: import("../utils/types").HexString<32>;
            };
            readonly meta: {
                secrethash: import("../utils/types").HexString<32>;
                direction: import("./state").Direction;
            };
        };
        error: undefined;
    };
    /** Partner acknowledge they received and processed our LockExpired */
    readonly success: ((payload: {
        secret: import("../utils/types").HexString<32>;
        txTimestamp: number;
        txHash: import("../utils/types").HexString<32>;
        txBlock: number;
        confirmed: boolean | undefined;
    }, meta: {
        secrethash: import("../utils/types").HexString<32>;
        direction: import("./state").Direction;
    }) => {
        readonly type: "transfer/secret/register/success";
        readonly payload: {
            secret: import("../utils/types").HexString<32>;
            txTimestamp: number;
            txHash: import("../utils/types").HexString<32>;
            txBlock: number;
            confirmed: boolean | undefined;
        };
        readonly meta: {
            secrethash: import("../utils/types").HexString<32>;
            direction: import("./state").Direction;
        };
    }) & {
        type: "transfer/secret/register/success";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "transfer/secret/register/success";
            readonly payload: {
                secret: import("../utils/types").HexString<32>;
                txTimestamp: number;
                txHash: import("../utils/types").HexString<32>;
                txBlock: number;
                confirmed: boolean | undefined;
            };
            readonly meta: {
                secrethash: import("../utils/types").HexString<32>;
                direction: import("./state").Direction;
            };
        };
        error: undefined;
    };
    readonly failure: ((payload: unknown, meta: {
        secrethash: import("../utils/types").HexString<32>;
        direction: import("./state").Direction;
    }) => {
        readonly type: "transfer/secret/register/failure";
        readonly payload: unknown;
        readonly meta: {
            secrethash: import("../utils/types").HexString<32>;
            direction: import("./state").Direction;
        };
        readonly error: true;
    }) & {
        type: "transfer/secret/register/failure";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "transfer/secret/register/failure";
            readonly payload: unknown;
            readonly meta: {
                secrethash: import("../utils/types").HexString<32>;
                direction: import("./state").Direction;
            };
            readonly error: true;
        };
        error: true;
    };
};
export declare namespace transferSecretRegister {
    interface request extends ActionType<typeof transferSecretRegister.request> {
    }
    interface success extends ActionType<typeof transferSecretRegister.success> {
    }
    interface failure extends ActionType<typeof transferSecretRegister.failure> {
    }
}
/** A valid SecretRequest received from target */
export declare const transferSecretRequest: ((payload: {
    message: SecretRequest & Readonly<{
        signature: import("../utils/types").HexString<65>;
    }>;
} & {
    userId?: string | undefined;
}, meta: {
    secrethash: import("../utils/types").HexString<32>;
    direction: import("./state").Direction;
}) => {
    readonly type: "transfer/secret/request";
    readonly payload: {
        message: SecretRequest & Readonly<{
            signature: import("../utils/types").HexString<65>;
        }>;
    } & {
        userId?: string | undefined;
    };
    readonly meta: {
        secrethash: import("../utils/types").HexString<32>;
        direction: import("./state").Direction;
    };
}) & {
    type: "transfer/secret/request";
    codec: t.Mixed;
    is: (a: unknown) => a is {
        readonly type: "transfer/secret/request";
        readonly payload: {
            message: SecretRequest & Readonly<{
                signature: import("../utils/types").HexString<65>;
            }>;
        } & {
            userId?: string | undefined;
        };
        readonly meta: {
            secrethash: import("../utils/types").HexString<32>;
            direction: import("./state").Direction;
        };
    };
    error: undefined;
};
export interface transferSecretRequest extends ActionType<typeof transferSecretRequest> {
}
/** A SecretReveal sent to target */
export declare const transferSecretReveal: ((payload: {
    message: SecretReveal & Readonly<{
        signature: import("../utils/types").HexString<65>;
    }>;
} & {
    userId?: string | undefined;
}, meta: {
    secrethash: import("../utils/types").HexString<32>;
    direction: import("./state").Direction;
}) => {
    readonly type: "transfer/secret/reveal";
    readonly payload: {
        message: SecretReveal & Readonly<{
            signature: import("../utils/types").HexString<65>;
        }>;
    } & {
        userId?: string | undefined;
    };
    readonly meta: {
        secrethash: import("../utils/types").HexString<32>;
        direction: import("./state").Direction;
    };
}) & {
    type: "transfer/secret/reveal";
    codec: t.Mixed;
    is: (a: unknown) => a is {
        readonly type: "transfer/secret/reveal";
        readonly payload: {
            message: SecretReveal & Readonly<{
                signature: import("../utils/types").HexString<65>;
            }>;
        } & {
            userId?: string | undefined;
        };
        readonly meta: {
            secrethash: import("../utils/types").HexString<32>;
            direction: import("./state").Direction;
        };
    };
    error: undefined;
};
export interface transferSecretReveal extends ActionType<typeof transferSecretReveal> {
}
export declare const transferUnlock: {
    readonly request: ((payload: {
        userId?: string | undefined;
    } | undefined, meta: {
        secrethash: import("../utils/types").HexString<32>;
        direction: import("./state").Direction;
    }) => {
        readonly type: "transfer/unlock/request";
        readonly payload: {
            userId?: string | undefined;
        } | undefined;
        readonly meta: {
            secrethash: import("../utils/types").HexString<32>;
            direction: import("./state").Direction;
        };
    }) & {
        type: "transfer/unlock/request";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "transfer/unlock/request";
            readonly payload: {
                userId?: string | undefined;
            } | undefined;
            readonly meta: {
                secrethash: import("../utils/types").HexString<32>;
                direction: import("./state").Direction;
            };
        };
        error: undefined;
    };
    /** Partner acknowledge they received and processed our LockExpired */
    readonly success: ((payload: {
        message: Unlock & Readonly<{
            signature: import("../utils/types").HexString<65>;
        }>;
        partner: Address;
    } & {
        userId?: string | undefined;
    }, meta: {
        secrethash: import("../utils/types").HexString<32>;
        direction: import("./state").Direction;
    }) => {
        readonly type: "transfer/unlock/success";
        readonly payload: {
            message: Unlock & Readonly<{
                signature: import("../utils/types").HexString<65>;
            }>;
            partner: Address;
        } & {
            userId?: string | undefined;
        };
        readonly meta: {
            secrethash: import("../utils/types").HexString<32>;
            direction: import("./state").Direction;
        };
    }) & {
        type: "transfer/unlock/success";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "transfer/unlock/success";
            readonly payload: {
                message: Unlock & Readonly<{
                    signature: import("../utils/types").HexString<65>;
                }>;
                partner: Address;
            } & {
                userId?: string | undefined;
            };
            readonly meta: {
                secrethash: import("../utils/types").HexString<32>;
                direction: import("./state").Direction;
            };
        };
        error: undefined;
    };
    readonly failure: ((payload: unknown, meta: {
        secrethash: import("../utils/types").HexString<32>;
        direction: import("./state").Direction;
    }) => {
        readonly type: "transfer/unlock/failure";
        readonly payload: unknown;
        readonly meta: {
            secrethash: import("../utils/types").HexString<32>;
            direction: import("./state").Direction;
        };
        readonly error: true;
    }) & {
        type: "transfer/unlock/failure";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "transfer/unlock/failure";
            readonly payload: unknown;
            readonly meta: {
                secrethash: import("../utils/types").HexString<32>;
                direction: import("./state").Direction;
            };
            readonly error: true;
        };
        error: true;
    };
};
export declare namespace transferUnlock {
    interface request extends ActionType<typeof transferUnlock.request> {
    }
    interface success extends ActionType<typeof transferUnlock.success> {
    }
    interface failure extends ActionType<typeof transferUnlock.failure> {
    }
}
/** Partner acknowledge they received and processed our Unlock */
export declare const transferUnlockProcessed: ((payload: {
    message: Processed & Readonly<{
        signature: import("../utils/types").HexString<65>;
    }>;
} & {
    userId?: string | undefined;
}, meta: {
    secrethash: import("../utils/types").HexString<32>;
    direction: import("./state").Direction;
}) => {
    readonly type: "transfer/unlock/processed";
    readonly payload: {
        message: Processed & Readonly<{
            signature: import("../utils/types").HexString<65>;
        }>;
    } & {
        userId?: string | undefined;
    };
    readonly meta: {
        secrethash: import("../utils/types").HexString<32>;
        direction: import("./state").Direction;
    };
}) & {
    type: "transfer/unlock/processed";
    codec: t.Mixed;
    is: (a: unknown) => a is {
        readonly type: "transfer/unlock/processed";
        readonly payload: {
            message: Processed & Readonly<{
                signature: import("../utils/types").HexString<65>;
            }>;
        } & {
            userId?: string | undefined;
        };
        readonly meta: {
            secrethash: import("../utils/types").HexString<32>;
            direction: import("./state").Direction;
        };
    };
    error: undefined;
};
export interface transferUnlockProcessed extends ActionType<typeof transferUnlockProcessed> {
}
/**
 * A request to expire a given transfer
 *
 * A transfer expiration request may fail for any reason
 * e.g. user rejected sign prompt. It should eventually get prompted again, on a future newBlock
 * action which sees this transfer should be expired but sent.expired didn't get set yet.
 */
export declare const transferExpire: {
    readonly request: ((_: undefined, meta: {
        secrethash: import("../utils/types").HexString<32>;
        direction: import("./state").Direction;
    }) => {
        readonly type: "transfer/expire/request";
        readonly meta: {
            secrethash: import("../utils/types").HexString<32>;
            direction: import("./state").Direction;
        };
    }) & {
        type: "transfer/expire/request";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "transfer/expire/request";
            readonly meta: {
                secrethash: import("../utils/types").HexString<32>;
                direction: import("./state").Direction;
            };
        };
        error: undefined;
    };
    /** Partner acknowledge they received and processed our LockExpired */
    readonly success: ((payload: {
        message: LockExpired & Readonly<{
            signature: import("../utils/types").HexString<65>;
        }>;
        partner: Address;
    }, meta: {
        secrethash: import("../utils/types").HexString<32>;
        direction: import("./state").Direction;
    }) => {
        readonly type: "transfer/expire/success";
        readonly payload: {
            message: LockExpired & Readonly<{
                signature: import("../utils/types").HexString<65>;
            }>;
            partner: Address;
        };
        readonly meta: {
            secrethash: import("../utils/types").HexString<32>;
            direction: import("./state").Direction;
        };
    }) & {
        type: "transfer/expire/success";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "transfer/expire/success";
            readonly payload: {
                message: LockExpired & Readonly<{
                    signature: import("../utils/types").HexString<65>;
                }>;
                partner: Address;
            };
            readonly meta: {
                secrethash: import("../utils/types").HexString<32>;
                direction: import("./state").Direction;
            };
        };
        error: undefined;
    };
    readonly failure: ((payload: unknown, meta: {
        secrethash: import("../utils/types").HexString<32>;
        direction: import("./state").Direction;
    }) => {
        readonly type: "transfer/expire/failure";
        readonly payload: unknown;
        readonly meta: {
            secrethash: import("../utils/types").HexString<32>;
            direction: import("./state").Direction;
        };
        readonly error: true;
    }) & {
        type: "transfer/expire/failure";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "transfer/expire/failure";
            readonly payload: unknown;
            readonly meta: {
                secrethash: import("../utils/types").HexString<32>;
                direction: import("./state").Direction;
            };
            readonly error: true;
        };
        error: true;
    };
};
export declare namespace transferExpire {
    interface request extends ActionType<typeof transferExpire.request> {
    }
    interface success extends ActionType<typeof transferExpire.success> {
    }
    interface failure extends ActionType<typeof transferExpire.failure> {
    }
}
/** Partner acknowledge they received and processed our LockExpired */
export declare const transferExpireProcessed: ((payload: {
    message: Processed & Readonly<{
        signature: import("../utils/types").HexString<65>;
    }>;
} & {
    userId?: string | undefined;
}, meta: {
    secrethash: import("../utils/types").HexString<32>;
    direction: import("./state").Direction;
}) => {
    readonly type: "transfer/expire/processed";
    readonly payload: {
        message: Processed & Readonly<{
            signature: import("../utils/types").HexString<65>;
        }>;
    } & {
        userId?: string | undefined;
    };
    readonly meta: {
        secrethash: import("../utils/types").HexString<32>;
        direction: import("./state").Direction;
    };
}) & {
    type: "transfer/expire/processed";
    codec: t.Mixed;
    is: (a: unknown) => a is {
        readonly type: "transfer/expire/processed";
        readonly payload: {
            message: Processed & Readonly<{
                signature: import("../utils/types").HexString<65>;
            }>;
        } & {
            userId?: string | undefined;
        };
        readonly meta: {
            secrethash: import("../utils/types").HexString<32>;
            direction: import("./state").Direction;
        };
    };
    error: undefined;
};
export interface transferExpireProcessed extends ActionType<typeof transferExpireProcessed> {
}
export declare const transferClear: ((payload: undefined, meta: {
    secrethash: import("../utils/types").HexString<32>;
    direction: import("./state").Direction;
}) => {
    readonly type: "transfer/clear";
    readonly payload: undefined;
    readonly meta: {
        secrethash: import("../utils/types").HexString<32>;
        direction: import("./state").Direction;
    };
}) & {
    type: "transfer/clear";
    codec: t.Mixed;
    is: (a: unknown) => a is {
        readonly type: "transfer/clear";
        readonly payload: undefined;
        readonly meta: {
            secrethash: import("../utils/types").HexString<32>;
            direction: import("./state").Direction;
        };
    };
    error: undefined;
};
export interface transferClear extends ActionType<typeof transferClear> {
}
export declare const transferLoad: ((payload: TransferState, meta: {
    secrethash: import("../utils/types").HexString<32>;
    direction: import("./state").Direction;
}) => {
    readonly type: "transfer/load";
    readonly payload: TransferState;
    readonly meta: {
        secrethash: import("../utils/types").HexString<32>;
        direction: import("./state").Direction;
    };
}) & {
    type: "transfer/load";
    codec: t.Mixed;
    is: (a: unknown) => a is {
        readonly type: "transfer/load";
        readonly payload: TransferState;
        readonly meta: {
            secrethash: import("../utils/types").HexString<32>;
            direction: import("./state").Direction;
        };
    };
    error: undefined;
};
export interface transferLoad extends ActionType<typeof transferLoad> {
}
/**
 * Request withdrawResolveEpic to resolve and emit a withdraw.request
 */
export declare const withdrawResolve: ((payload: {
    coopSettle: true;
} | undefined, meta: {
    direction: import("./state").Direction;
    tokenNetwork: Address;
    partner: Address;
    totalWithdraw: UInt<32>;
    expiration: number;
}) => {
    readonly type: "withdraw/resolve";
    readonly payload: {
        coopSettle: true;
    } | undefined;
    readonly meta: {
        direction: import("./state").Direction;
        tokenNetwork: Address;
        partner: Address;
        totalWithdraw: UInt<32>;
        expiration: number;
    };
}) & {
    type: "withdraw/resolve";
    codec: t.Mixed;
    is: (a: unknown) => a is {
        readonly type: "withdraw/resolve";
        readonly payload: {
            coopSettle: true;
        } | undefined;
        readonly meta: {
            direction: import("./state").Direction;
            tokenNetwork: Address;
            partner: Address;
            totalWithdraw: UInt<32>;
            expiration: number;
        };
    };
    error: undefined;
};
export interface withdrawResolve extends ActionType<typeof withdrawResolve> {
}
/**
 * Start a withdraw
 * - request: request to start a withdraw
 * - success: withdraw finished on-chain
 * - failure: something went wrong generating or processing a request
 */
export declare const withdraw: {
    readonly request: ((payload: {
        coopSettle: boolean;
    } | undefined, meta: {
        direction: import("./state").Direction;
        tokenNetwork: Address;
        partner: Address;
        totalWithdraw: UInt<32>;
        expiration: number;
    }) => {
        readonly type: "withdraw/request";
        readonly payload: {
            coopSettle: boolean;
        } | undefined;
        readonly meta: {
            direction: import("./state").Direction;
            tokenNetwork: Address;
            partner: Address;
            totalWithdraw: UInt<32>;
            expiration: number;
        };
    }) & {
        type: "withdraw/request";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "withdraw/request";
            readonly payload: {
                coopSettle: boolean;
            } | undefined;
            readonly meta: {
                direction: import("./state").Direction;
                tokenNetwork: Address;
                partner: Address;
                totalWithdraw: UInt<32>;
                expiration: number;
            };
        };
        error: undefined;
    };
    /** Partner acknowledge they received and processed our LockExpired */
    readonly success: ((payload: {
        txHash: import("../utils/types").HexString<32>;
        txBlock: number;
        confirmed: boolean | undefined;
    }, meta: {
        direction: import("./state").Direction;
        tokenNetwork: Address;
        partner: Address;
        totalWithdraw: UInt<32>;
        expiration: number;
    }) => {
        readonly type: "withdraw/success";
        readonly payload: {
            txHash: import("../utils/types").HexString<32>;
            txBlock: number;
            confirmed: boolean | undefined;
        };
        readonly meta: {
            direction: import("./state").Direction;
            tokenNetwork: Address;
            partner: Address;
            totalWithdraw: UInt<32>;
            expiration: number;
        };
    }) & {
        type: "withdraw/success";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "withdraw/success";
            readonly payload: {
                txHash: import("../utils/types").HexString<32>;
                txBlock: number;
                confirmed: boolean | undefined;
            };
            readonly meta: {
                direction: import("./state").Direction;
                tokenNetwork: Address;
                partner: Address;
                totalWithdraw: UInt<32>;
                expiration: number;
            };
        };
        error: undefined;
    };
    readonly failure: ((payload: unknown, meta: {
        direction: import("./state").Direction;
        tokenNetwork: Address;
        partner: Address;
        totalWithdraw: UInt<32>;
        expiration: number;
    }) => {
        readonly type: "withdraw/failure";
        readonly payload: unknown;
        readonly meta: {
            direction: import("./state").Direction;
            tokenNetwork: Address;
            partner: Address;
            totalWithdraw: UInt<32>;
            expiration: number;
        };
        readonly error: true;
    }) & {
        type: "withdraw/failure";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "withdraw/failure";
            readonly payload: unknown;
            readonly meta: {
                direction: import("./state").Direction;
                tokenNetwork: Address;
                partner: Address;
                totalWithdraw: UInt<32>;
                expiration: number;
            };
            readonly error: true;
        };
        error: true;
    };
};
export declare namespace withdraw {
    interface request extends ActionType<typeof withdraw.request> {
    }
    interface success extends ActionType<typeof withdraw.success> {
    }
    interface failure extends ActionType<typeof withdraw.failure> {
    }
}
/**
 * Withdraw messages going through:
 * - request: WithdrawRequest sent or received
 * - success: WithdrawConfirmation sent or received
 * - failure: something went wrong processing WithdrawRequest or WithdrawConfirmation messages
 */
export declare const withdrawMessage: {
    readonly request: ((payload: {
        message: WithdrawRequest & Readonly<{
            signature: import("../utils/types").HexString<65>;
        }>;
    }, meta: {
        direction: import("./state").Direction;
        tokenNetwork: Address;
        partner: Address;
        totalWithdraw: UInt<32>;
        expiration: number;
    }) => {
        readonly type: "withdraw/message/request";
        readonly payload: {
            message: WithdrawRequest & Readonly<{
                signature: import("../utils/types").HexString<65>;
            }>;
        };
        readonly meta: {
            direction: import("./state").Direction;
            tokenNetwork: Address;
            partner: Address;
            totalWithdraw: UInt<32>;
            expiration: number;
        };
    }) & {
        type: "withdraw/message/request";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "withdraw/message/request";
            readonly payload: {
                message: WithdrawRequest & Readonly<{
                    signature: import("../utils/types").HexString<65>;
                }>;
            };
            readonly meta: {
                direction: import("./state").Direction;
                tokenNetwork: Address;
                partner: Address;
                totalWithdraw: UInt<32>;
                expiration: number;
            };
        };
        error: undefined;
    };
    /** Partner acknowledge they received and processed our LockExpired */
    readonly success: ((payload: {
        message: WithdrawConfirmation & Readonly<{
            signature: import("../utils/types").HexString<65>;
        }>;
    }, meta: {
        direction: import("./state").Direction;
        tokenNetwork: Address;
        partner: Address;
        totalWithdraw: UInt<32>;
        expiration: number;
    }) => {
        readonly type: "withdraw/message/success";
        readonly payload: {
            message: WithdrawConfirmation & Readonly<{
                signature: import("../utils/types").HexString<65>;
            }>;
        };
        readonly meta: {
            direction: import("./state").Direction;
            tokenNetwork: Address;
            partner: Address;
            totalWithdraw: UInt<32>;
            expiration: number;
        };
    }) & {
        type: "withdraw/message/success";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "withdraw/message/success";
            readonly payload: {
                message: WithdrawConfirmation & Readonly<{
                    signature: import("../utils/types").HexString<65>;
                }>;
            };
            readonly meta: {
                direction: import("./state").Direction;
                tokenNetwork: Address;
                partner: Address;
                totalWithdraw: UInt<32>;
                expiration: number;
            };
        };
        error: undefined;
    };
    readonly failure: ((payload: unknown, meta: {
        direction: import("./state").Direction;
        tokenNetwork: Address;
        partner: Address;
        totalWithdraw: UInt<32>;
        expiration: number;
    }) => {
        readonly type: "withdraw/message/failure";
        readonly payload: unknown;
        readonly meta: {
            direction: import("./state").Direction;
            tokenNetwork: Address;
            partner: Address;
            totalWithdraw: UInt<32>;
            expiration: number;
        };
        readonly error: true;
    }) & {
        type: "withdraw/message/failure";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "withdraw/message/failure";
            readonly payload: unknown;
            readonly meta: {
                direction: import("./state").Direction;
                tokenNetwork: Address;
                partner: Address;
                totalWithdraw: UInt<32>;
                expiration: number;
            };
            readonly error: true;
        };
        error: true;
    };
};
export declare namespace withdrawMessage {
    interface request extends ActionType<typeof withdrawMessage.request> {
    }
    interface success extends ActionType<typeof withdrawMessage.success> {
    }
    interface failure extends ActionType<typeof withdrawMessage.failure> {
    }
}
/**
 * Signals this withdraw is "busy" performing contract's transaction (either setTotalWithdraw
 * or cooperativeSettle). Is "unlocked" by the respective withdraw.success|failure
 */
export declare const withdrawBusy: ((payload: undefined, meta: {
    direction: import("./state").Direction;
    tokenNetwork: Address;
    partner: Address;
    totalWithdraw: UInt<32>;
    expiration: number;
}) => {
    readonly type: "withdraw/busy";
    readonly payload: undefined;
    readonly meta: {
        direction: import("./state").Direction;
        tokenNetwork: Address;
        partner: Address;
        totalWithdraw: UInt<32>;
        expiration: number;
    };
}) & {
    type: "withdraw/busy";
    codec: t.Mixed;
    is: (a: unknown) => a is {
        readonly type: "withdraw/busy";
        readonly payload: undefined;
        readonly meta: {
            direction: import("./state").Direction;
            tokenNetwork: Address;
            partner: Address;
            totalWithdraw: UInt<32>;
            expiration: number;
        };
    };
    error: undefined;
};
export interface withdrawBusy extends ActionType<typeof withdrawBusy> {
}
/**
 * Expires a withdraw
 * - request: request to expire a past request
 * - success: WithdrawExpired sent or received
 * - failure: something went wrong generating or processing a request
 */
export declare const withdrawExpire: {
    readonly request: ((payload: undefined, meta: {
        direction: import("./state").Direction;
        tokenNetwork: Address;
        partner: Address;
        totalWithdraw: UInt<32>;
        expiration: number;
    }) => {
        readonly type: "withdraw/expire/request";
        readonly payload: undefined;
        readonly meta: {
            direction: import("./state").Direction;
            tokenNetwork: Address;
            partner: Address;
            totalWithdraw: UInt<32>;
            expiration: number;
        };
    }) & {
        type: "withdraw/expire/request";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "withdraw/expire/request";
            readonly payload: undefined;
            readonly meta: {
                direction: import("./state").Direction;
                tokenNetwork: Address;
                partner: Address;
                totalWithdraw: UInt<32>;
                expiration: number;
            };
        };
        error: undefined;
    };
    /** Partner acknowledge they received and processed our LockExpired */
    readonly success: ((payload: {
        message: WithdrawExpired & Readonly<{
            signature: import("../utils/types").HexString<65>;
        }>;
    }, meta: {
        direction: import("./state").Direction;
        tokenNetwork: Address;
        partner: Address;
        totalWithdraw: UInt<32>;
        expiration: number;
    }) => {
        readonly type: "withdraw/expire/success";
        readonly payload: {
            message: WithdrawExpired & Readonly<{
                signature: import("../utils/types").HexString<65>;
            }>;
        };
        readonly meta: {
            direction: import("./state").Direction;
            tokenNetwork: Address;
            partner: Address;
            totalWithdraw: UInt<32>;
            expiration: number;
        };
    }) & {
        type: "withdraw/expire/success";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "withdraw/expire/success";
            readonly payload: {
                message: WithdrawExpired & Readonly<{
                    signature: import("../utils/types").HexString<65>;
                }>;
            };
            readonly meta: {
                direction: import("./state").Direction;
                tokenNetwork: Address;
                partner: Address;
                totalWithdraw: UInt<32>;
                expiration: number;
            };
        };
        error: undefined;
    };
    readonly failure: ((payload: unknown, meta: {
        direction: import("./state").Direction;
        tokenNetwork: Address;
        partner: Address;
        totalWithdraw: UInt<32>;
        expiration: number;
    }) => {
        readonly type: "withdraw/expire/failure";
        readonly payload: unknown;
        readonly meta: {
            direction: import("./state").Direction;
            tokenNetwork: Address;
            partner: Address;
            totalWithdraw: UInt<32>;
            expiration: number;
        };
        readonly error: true;
    }) & {
        type: "withdraw/expire/failure";
        codec: t.Mixed;
        is: (a: unknown) => a is {
            readonly type: "withdraw/expire/failure";
            readonly payload: unknown;
            readonly meta: {
                direction: import("./state").Direction;
                tokenNetwork: Address;
                partner: Address;
                totalWithdraw: UInt<32>;
                expiration: number;
            };
            readonly error: true;
        };
        error: true;
    };
};
export declare namespace withdrawExpire {
    interface request extends ActionType<typeof withdrawExpire.request> {
    }
    interface success extends ActionType<typeof withdrawExpire.success> {
    }
    interface failure extends ActionType<typeof withdrawExpire.failure> {
    }
}
export declare const withdrawCompleted: ((payload: undefined, meta: {
    direction: import("./state").Direction;
    tokenNetwork: Address;
    partner: Address;
    totalWithdraw: UInt<32>;
    expiration: number;
}) => {
    readonly type: "withdraw/completed";
    readonly payload: undefined;
    readonly meta: {
        direction: import("./state").Direction;
        tokenNetwork: Address;
        partner: Address;
        totalWithdraw: UInt<32>;
        expiration: number;
    };
}) & {
    type: "withdraw/completed";
    codec: t.Mixed;
    is: (a: unknown) => a is {
        readonly type: "withdraw/completed";
        readonly payload: undefined;
        readonly meta: {
            direction: import("./state").Direction;
            tokenNetwork: Address;
            partner: Address;
            totalWithdraw: UInt<32>;
            expiration: number;
        };
    };
    error: undefined;
};
export interface withdrawCompleted extends ActionType<typeof withdrawCompleted> {
}