@miradexio/client 0.1.0

package/dist/engine/flows/swap-flow.js

@@ -0,0 +1,720 @@
+import { ApiError, NetworkError } from '../../api/index.js';
+import { TERMINAL_STATUSES, isAtomicProtocolData } from '../../types/index.js';
+import { createFlowContext, mergeFlowContext, validateBase, validatePopulated, validateVerified, } from '../flow-context.js';
+import { solveChallenge, encodePowHeader } from '../../lib/pow-solver.js';
+import { verifyDepositAddress } from '../../verification/index.js';
+import { delay } from '../../lib/delay.js';
+import { mapServerStatus } from '../pipeline.js';
+const DEFAULT_POLL_MS = 5_000;
+const DEFAULT_POLL_TIMEOUT_MS = 3_600_000;
+const MAX_TRANSIENT_RETRIES = 5;
+const TRANSIENT_RETRY_MS = 5_000;
+/**
+ * Built-in defaults for SwapFlow. Consumers can inspect these without
+ * instantiating a flow and may override via `SwapFlowOptions`.
+ */
+export const SWAP_FLOW_CONFIG = {
+    pollMs: DEFAULT_POLL_MS,
+    pollTimeoutMs: DEFAULT_POLL_TIMEOUT_MS,
+    maxRetries: MAX_TRANSIENT_RETRIES,
+    retryMs: TRANSIENT_RETRY_MS,
+};
+// Server-side errors whose CAUSE is the user's request (slippage band, memo
+// shape, dust amount, ...), not a transient server condition. They will fail
+// the same way every time, so retrying just burns the registry's swap-create
+// timeout and surfaces the wrong message ("timeout") instead of the real one.
+//
+// Detected by message shape — these come back as 500s from THORChain's
+// `simulate_swap` handler and similar provider validators, but the body has a
+// stable substring we can match on.
+const PERMANENT_API_ERROR_PATTERNS = [
+    /less than price limit/i, // THORChain LIM < quote actual at simulate time
+    /swap_too_small/i, // THORChain min-amount rejection
+    /memo too long/i, // memo overflow
+];
+function isPermanentApiError(err) {
+    if (!(err instanceof ApiError))
+        return false;
+    return PERMANENT_API_ERROR_PATTERNS.some((re) => re.test(err.message));
+}
+function isTransientError(err) {
+    if (err instanceof NetworkError)
+        return true;
+    if (err instanceof ApiError) {
+        if (isPermanentApiError(err))
+            return false;
+        if (err.statusCode >= 500)
+            return true;
+        if (err.statusCode === 429)
+            return true;
+    }
+    return false;
+}
+/**
+ * Translate a raw API/network error into a message that tells the user what
+ * to do, not what the server logged. Falls back to the original message for
+ * cases we don't have a curated translation for.
+ */
+function humanizeApiError(err) {
+    if (err instanceof ApiError) {
+        if (/less than price limit/i.test(err.message)) {
+            return 'Slippage tolerance is too tight for current market conditions. Increase slippage in the gear icon and try again.';
+        }
+        if (/swap_too_small/i.test(err.message)) {
+            return 'Amount too small for this provider. Increase the swap amount and try again.';
+        }
+    }
+    if (err instanceof NetworkError) {
+        return 'Network error reaching the swap server. Check your connection and try again.';
+    }
+    return err instanceof Error ? err.message : String(err);
+}
+export class SwapFlow {
+    api;
+    platform;
+    config;
+    emitFn;
+    abortController = null;
+    pollMs;
+    pollTimeoutMs;
+    retryMs;
+    maxRetries;
+    flowCtx = null;
+    lastPhase = 'idle';
+    lastPollKey = null;
+    constructor(api, platform, config, emitFn, options) {
+        this.api = api;
+        this.platform = platform;
+        this.config = config;
+        this.emitFn = emitFn;
+        this.pollMs = options?.pollMs ?? DEFAULT_POLL_MS;
+        this.pollTimeoutMs = options?.pollTimeoutMs ?? DEFAULT_POLL_TIMEOUT_MS;
+        this.retryMs = options?.retryMs ?? TRANSIENT_RETRY_MS;
+        this.maxRetries = options?.maxRetries ?? MAX_TRANSIENT_RETRIES;
+    }
+    get signal() {
+        return this.abortController?.signal ?? AbortSignal.abort();
+    }
+    get logger() {
+        return this.platform.logger;
+    }
+    setFlowContext(partial) {
+        this.flowCtx = this.flowCtx
+            ? mergeFlowContext(this.flowCtx, partial)
+            : createFlowContext(partial);
+    }
+    requirePopulated(phase) {
+        if (!this.flowCtx) {
+            this.emitError(phase, 'FlowContext not initialized');
+            return null;
+        }
+        const result = validatePopulated(this.flowCtx, phase);
+        if (result.ok)
+            return result.data;
+        this.emitError(phase, result.error.message);
+        return null;
+    }
+    requireVerified(phase) {
+        if (!this.flowCtx) {
+            this.emitError(phase, 'FlowContext not initialized');
+            return null;
+        }
+        const result = validateVerified(this.flowCtx, phase);
+        if (result.ok)
+            return result.data;
+        this.emitError(phase, result.error.message);
+        return null;
+    }
+    emitError(phase, message) {
+        this.transition({
+            phase: 'failed',
+            snapshot: this.flowCtx,
+            error: `[${phase}] ${message}`,
+        });
+    }
+    transition(state) {
+        const prevPhase = this.lastPhase;
+        if (state.phase === prevPhase)
+            return;
+        this.lastPhase = state.phase;
+        this.logger.info({ phase: state.phase, prevPhase, swapId: this.flowCtx?.swapId ?? null, provider: this.flowCtx?.provider ?? null }, 'Swap phase transition');
+        this.emitFn(state);
+    }
+    cancel() {
+        this.abortController?.abort();
+    }
+    async start(params) {
+        this.abortController = new AbortController();
+        const provider = params.selectedQuote.provider;
+        this.logger.info({ provider, fromToken: params.fromToken, toToken: params.toToken, amount: params.amount }, 'SwapFlow.start()');
+        this.setFlowContext({
+            fromToken: params.fromToken,
+            toToken: params.toToken,
+            depositAmount: params.amount,
+            destAddress: params.destAddress,
+            refundAddress: params.refundAddress,
+            provider,
+            extra: { text: 'Solving proof of work...', type: 'message' },
+        });
+        try {
+            this.transition({ phase: 'solving-pow', snapshot: this.flowCtx });
+            const swap = await this.createSwapWithRetry(params, provider);
+            this.logger.info({ swapNumber: swap.swapNumber, depositAddress: swap.depositAddress }, 'Swap created');
+            this.checkAborted();
+            // Expose swapId/swapNumber to listeners (notably EngineRegistry's
+            // waitForFirstSwapId) BEFORE verification runs. emitAwaitingDeposit
+            // can take 30+ s on chainflip's REST indexer lag — without this
+            // early emit the registry's 30 s timeout races against verification
+            // and orphans the engine. depositAddr is intentionally NOT exposed
+            // here; it stays gated by the verification-success branch inside
+            // emitAwaitingDeposit so a verification failure can never leak the
+            // address to the UI.
+            this.setFlowContext({ swapId: swap.swapNumber, swapNumber: swap.swapNumber });
+            // Same-phase emit (still 'creating-swap') — bypass transition()'s
+            // dedup guard so the snapshot update reaches subscribers.
+            this.emitFn({ phase: 'creating-swap', snapshot: this.flowCtx });
+            await this.emitAwaitingDeposit(swap, params, provider);
+            await this.pollLoop(swap.swapNumber);
+        }
+        catch (err) {
+            this.handleError(err);
+        }
+    }
+    /**
+     * Resume an existing swap. The engine has typically just fetched
+     * `detail` to determine which flow to dispatch to; pass it in to skip a
+     * redundant `getSwapDetail` round-trip. Without this, a brief network
+     * blip on the second fetch sends `ApiClient.withRetry` into an
+     * unbounded `network`/`server` retry loop (capped at 60s per backoff,
+     * exponential growth), keeping the UI on `creating-swap` for minutes
+     * before the call eventually succeeds.
+     */
+    async resume(swapId, provider, fromToken, toToken, cachedDetail) {
+        this.abortController = new AbortController();
+        this.logger.info({ swapId, provider, cached: cachedDetail !== undefined }, 'SwapFlow.resume()');
+        this.setFlowContext({
+            provider, fromToken, toToken, swapId,
+            extra: { text: 'Loading swap...', type: 'message' },
+        });
+        try {
+            this.transition({ phase: 'creating-swap', snapshot: this.flowCtx });
+            const detail = cachedDetail ?? (await this.fetchDetailWithRetry(swapId));
+            if (TERMINAL_STATUSES.has(detail.status)) {
+                this.logger.info({ swapId, status: detail.status }, 'Resumed swap is terminal');
+                // Hydrate receipt fields from `detail` before emitting the terminal
+                // phase. The live awaiting-deposit code path populates these into
+                // flowCtx, but on terminal-resume we never reach that path — without
+                // this hydration the rendered receipt is missing addresses, expected
+                // out, and USD values, and the swap-info card disappears on reload.
+                // Skips re-running verifyDepositAddress: verification is a pre-commit
+                // gate; once a swap is terminal, the outcome (completed/refunded) is
+                // the source of truth, not a fresh chain query against possibly-
+                // rotated vaults.
+                this.setFlowContext({
+                    depositAddr: detail.depositAddress,
+                    destAddress: detail.destAddress,
+                    refundAddress: detail.refundAddress,
+                    expectedOut: detail.expectedAmountOut,
+                    amountInUsd: detail.amountInUsd,
+                    expectedOutUsd: detail.expectedAmountOutUsd,
+                    provider,
+                });
+                this.emitTerminal(detail, fromToken, toToken);
+                return;
+            }
+            this.checkAborted();
+            // Hydrate flow context (QR, addresses, verification) but pick the
+            // initial phase based on the ACTUAL server status — don't pretend
+            // we're awaiting deposit if the swap is already past that point.
+            await this.emitInitialResumePhase(detail, {
+                destAddress: detail.destAddress,
+                refundAddress: detail.refundAddress ?? '',
+                toToken, fromToken, amount: detail.amountIn,
+                fromChain: detail.fromChain,
+                toChain: detail.toChain,
+            }, provider);
+            await this.pollLoop(swapId);
+        }
+        catch (err) {
+            this.handleError(err);
+        }
+    }
+    async fetchDetailWithRetry(swapId) {
+        let lastErr;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            try {
+                return await this.api.getSwapDetail(swapId);
+            }
+            catch (err) {
+                if (!isTransientError(err))
+                    throw err;
+                lastErr = err;
+                const msg = err instanceof Error ? err.message : String(err);
+                this.logger.warn({ swapId, attempt: attempt + 1, error: msg }, 'Server error fetching swap, retrying');
+                this.setFlowContext({
+                    extra: { text: `Server error, retrying (${attempt + 1}/${this.maxRetries})...`, type: 'warning' },
+                });
+                this.transition({ phase: 'creating-swap', snapshot: this.flowCtx });
+                await delay(this.retryMs * (attempt + 1), this.signal).catch(() => { });
+                this.checkAborted();
+            }
+        }
+        throw lastErr ?? new Error(`Failed to fetch swap ${swapId} after retries`);
+    }
+    async createSwapWithRetry(params, provider) {
+        let lastErr;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            try {
+                const challenge = await this.api.getChallenge();
+                const solution = await solveChallenge(challenge);
+                const powHeader = encodePowHeader(solution);
+                this.logger.debug({ algorithm: challenge.algorithm, attempt }, 'PoW challenge solved');
+                this.checkAborted();
+                if (attempt === 0) {
+                    this.setFlowContext({ extra: { text: 'Creating swap...', type: 'message' } });
+                }
+                this.transition({ phase: 'creating-swap', snapshot: this.flowCtx });
+                return await this.api.createSwap({
+                    from: params.fromToken, to: params.toToken, amount: params.amount,
+                    destAddress: params.destAddress, refundAddress: params.refundAddress,
+                    provider, variantId: params.selectedQuote.variantId,
+                    fromChain: params.fromChain, toChain: params.toChain,
+                    slippageBps: params.slippageBps ?? this.config.slippageBps,
+                }, powHeader);
+            }
+            catch (err) {
+                if (!isTransientError(err))
+                    throw err;
+                lastErr = err;
+                const msg = err instanceof Error ? err.message : String(err);
+                this.logger.warn({ attempt: attempt + 1, error: msg }, 'Server error during swap creation, retrying');
+                this.setFlowContext({
+                    extra: { text: `Server error, retrying (${attempt + 1}/${this.maxRetries})...`, type: 'warning' },
+                });
+                this.transition({ phase: 'creating-swap', snapshot: this.flowCtx });
+                await delay(this.retryMs * (attempt + 1), this.signal).catch(() => { });
+                this.checkAborted();
+            }
+        }
+        throw lastErr ?? new Error('Failed to create swap after retries');
+    }
+    async emitAwaitingDeposit(swap, params, provider) {
+        let verification = null;
+        if (swap.depositAddress && swap.verification) {
+            verification = await verifyDepositAddress({
+                depositAddress: swap.depositAddress,
+                verification: swap.verification,
+                destAddress: params.destAddress,
+                refundAddress: params.refundAddress,
+                toToken: params.toToken,
+                amount: params.amount ?? swap.amountIn,
+                fromChain: params.fromChain,
+                toChain: params.toChain,
+                fromToken: params.fromToken,
+                network: this.config.network,
+                protocol: isAtomicProtocolData(swap.protocolData)
+                    ? {
+                        psbt: swap.protocolData.psbt,
+                        lock_address: swap.protocolData.lock_address,
+                        timelock_blocks: swap.protocolData.timelock_blocks,
+                    }
+                    : undefined,
+                expectedAmountOut: swap.expectedAmountOut ?? undefined,
+                expectedDestAddress: params.destAddress,
+                fetchFn: this.config.fetchFn,
+                signal: this.signal,
+            });
+        }
+        // Bail out before any state mutation if the engine was destroyed
+        // mid-verification. With Fix 2 the verifier's own retry loop and
+        // fetches respect the abort signal, but a verification that already
+        // resolved on its last successful attempt before destroy() fired
+        // would still fall through to setFlowContext + transition without
+        // this guard.
+        this.checkAborted();
+        // Log the full check list at info level on every verification — both
+        // pass and fail. Each entry carries `name`, `passed`, and `detail`
+        // (the broker mismatch reason for failed checks). This is the
+        // primary diagnostic surface when a verification regresses; the
+        // narrow info log on the success path was hiding the data the
+        // operator actually needs to see.
+        this.logger.info({
+            swapNumber: swap.swapNumber,
+            verified: verification?.verified ?? null,
+            provider: verification?.provider ?? null,
+            checks: verification?.checks ?? [],
+        }, 'Deposit address verification');
+        if (verification && !verification.verified) {
+            const failedChecks = verification.checks.filter((c) => !c.passed);
+            this.logger.warn({
+                swapNumber: swap.swapNumber,
+                provider: verification.provider,
+                failedChecks,
+                allChecks: verification.checks,
+            }, 'Deposit address verification FAILED');
+            // Withhold depositAddr / qr / destAddress on failure so the UI can't
+            // accidentally invite a deposit. Keep verification + identifiers so
+            // the failure screen has a swap reference and can show why.
+            this.setFlowContext({
+                verification,
+                swapId: swap.swapNumber,
+                swapNumber: swap.swapNumber,
+                depositAddr: null,
+                destAddress: null,
+                qr: null,
+                extra: {
+                    text: "We couldn't verify this swap with the provider. To stay safe, please try a different provider or start a new swap.",
+                    type: 'error',
+                },
+            });
+            const baseResult = validateBase(this.flowCtx, 'verification-failed');
+            if (!baseResult.ok) {
+                this.logger.error({ error: baseResult.error }, 'verification-failed FlowContext invalid');
+                return;
+            }
+            this.transition({ phase: 'verification-failed', snapshot: baseResult.data });
+            return;
+        }
+        const depositAddr = swap.depositAddress ?? '';
+        let qr = null;
+        if (depositAddr) {
+            try {
+                qr = await this.platform.generateQr(depositAddr);
+            }
+            catch { /* non-fatal */ }
+        }
+        let verificationSourceUrl = null;
+        if (swap.verification) {
+            if ('status_url' in swap.verification)
+                verificationSourceUrl = swap.verification.status_url;
+            else if ('inbound_addresses_url' in swap.verification)
+                verificationSourceUrl = swap.verification.inbound_addresses_url;
+        }
+        this.setFlowContext({
+            swapId: swap.swapNumber, swapNumber: swap.swapNumber, provider,
+            depositAddr, depositAmount: swap.amountIn,
+            destAddress: params.destAddress,
+            refundAddress: params.refundAddress,
+            amountInUsd: swap.amountInUsd ?? null,
+            expectedOut: swap.expectedAmountOut ?? null,
+            expectedOutUsd: swap.expectedAmountOutUsd ?? null,
+            expiresAt: swap.expiresAt ?? null,
+            qr, verification: verification ?? {
+                verified: false,
+                provider,
+                checks: [{ name: 'Server verification', passed: false, detail: 'Pending' }],
+                timestamp: Date.now(),
+            },
+            verificationSourceUrl,
+            extra: { text: `Awaiting deposit to ${depositAddr.slice(0, 16)}...`, type: 'message' },
+        });
+        const populated = this.requirePopulated('awaiting-deposit');
+        if (!populated)
+            return;
+        this.transition({ phase: 'awaiting-deposit', snapshot: populated });
+    }
+    /**
+     * Hydrate flow context and pick the initial phase based on the actual
+     * server status. Called from resume() so a swap that's already past the
+     * deposit stage doesn't briefly flash through `awaiting-deposit` before
+     * the first poll tick catches up.
+     */
+    async emitInitialResumePhase(detail, params, provider) {
+        // Fast path for pre-deposit statuses: reuse the existing emit that
+        // emits `awaiting-deposit` with QR + verification context.
+        const preDepositStatuses = new Set([
+            'initializing',
+            'pending',
+            'awaiting_funding',
+        ]);
+        if (preDepositStatuses.has(detail.status)) {
+            await this.emitAwaitingDeposit(detail, params, provider);
+            return;
+        }
+        // Post-deposit: hydrate the context enough to satisfy `requireVerified`
+        // for later transitions, then jump straight to the right phase.
+        let verification = null;
+        if (detail.depositAddress && detail.verification) {
+            try {
+                verification = await verifyDepositAddress({
+                    depositAddress: detail.depositAddress,
+                    verification: detail.verification,
+                    destAddress: params.destAddress,
+                    refundAddress: params.refundAddress,
+                    toToken: params.toToken,
+                    amount: params.amount ?? detail.amountIn,
+                    fromChain: params.fromChain,
+                    toChain: params.toChain,
+                    fromToken: params.fromToken,
+                    network: this.config.network,
+                    protocol: isAtomicProtocolData(detail.protocolData)
+                        ? {
+                            psbt: detail.protocolData.psbt,
+                            lock_address: detail.protocolData.lock_address,
+                            timelock_blocks: detail.protocolData.timelock_blocks,
+                        }
+                        : undefined,
+                    expectedAmountOut: detail.expectedAmountOut ?? undefined,
+                    expectedDestAddress: params.destAddress,
+                    fetchFn: this.config.fetchFn,
+                    signal: this.signal,
+                });
+            }
+            catch {
+                // Best-effort on resume — don't block if verification upstream fails.
+            }
+        }
+        // Symmetric to `emitAwaitingDeposit`: log the full check list so the
+        // operator can see exactly which check fired and why. Resume's
+        // post-deposit path doesn't gate on verification (the swap is already
+        // past that point), but the diagnostic value of the log is the same.
+        this.logger.info({
+            swapNumber: detail.swapNumber,
+            status: detail.status,
+            verified: verification?.verified ?? null,
+            provider: verification?.provider ?? null,
+            checks: verification?.checks ?? [],
+        }, 'Deposit address verification (resume post-deposit)');
+        let verificationSourceUrl = null;
+        if (detail.verification) {
+            if ('status_url' in detail.verification)
+                verificationSourceUrl = detail.verification.status_url;
+            else if ('inbound_addresses_url' in detail.verification)
+                verificationSourceUrl = detail.verification.inbound_addresses_url;
+        }
+        const depositAddr = detail.depositAddress ?? '';
+        let qr = null;
+        if (depositAddr) {
+            try {
+                qr = await this.platform.generateQr(depositAddr);
+            }
+            catch {
+                // Non-fatal — a post-deposit resume can tolerate a missing QR.
+            }
+        }
+        this.setFlowContext({
+            swapId: detail.swapNumber,
+            swapNumber: detail.swapNumber,
+            provider,
+            depositAddr,
+            depositAmount: detail.amountIn,
+            destAddress: params.destAddress,
+            refundAddress: params.refundAddress,
+            amountInUsd: detail.amountInUsd ?? null,
+            expectedOut: detail.expectedAmountOut ?? null,
+            expectedOutUsd: detail.expectedAmountOutUsd ?? null,
+            expiresAt: detail.expiresAt ?? null,
+            qr,
+            verification: verification ?? {
+                verified: true,
+                provider,
+                checks: [{ name: 'Server verification', passed: true, detail: 'Resumed' }],
+                timestamp: Date.now(),
+            },
+            verificationSourceUrl,
+        });
+        const verified = this.requireVerified(`resume:${detail.status}`);
+        if (!verified)
+            return;
+        switch (detail.status) {
+            case 'deposited':
+                this.setFlowContext({ extra: { text: 'Confirming deposit...', type: 'message' } });
+                this.transition({
+                    phase: 'confirming',
+                    snapshot: verified,
+                    requiredAction: detail.requiredAction ?? null,
+                });
+                return;
+            case 'swapping':
+                this.setFlowContext({ extra: { text: 'Swapping...', type: 'message' } });
+                this.transition({
+                    phase: 'swapping',
+                    snapshot: verified,
+                    requiredAction: detail.requiredAction ?? null,
+                });
+                return;
+            case 'sending':
+                this.setFlowContext({ extra: { text: 'Sending output...', type: 'message' } });
+                this.transition({ phase: 'sending', snapshot: verified });
+                return;
+            case 'cancelling': {
+                const msg = detail.requiredAction?.message ??
+                    'Swap is cancelling — refund in progress. Waiting for terminal status.';
+                this.setFlowContext({ extra: { text: msg, type: 'message' } });
+                this.transition({
+                    phase: 'cancelling',
+                    snapshot: verified,
+                    requiredAction: detail.requiredAction ?? null,
+                });
+                return;
+            }
+            default:
+                // Unknown non-terminal status — land on awaiting-deposit as a
+                // safe default (poll loop will correct on first tick).
+                await this.emitAwaitingDeposit(detail, params, provider);
+                return;
+        }
+    }
+    async pollLoop(swapId) {
+        const deadline = Date.now() + this.pollTimeoutMs;
+        let tick = 0;
+        while (Date.now() < deadline && !this.signal.aborted) {
+            await delay(this.pollMs, this.signal).catch(() => { });
+            if (this.signal.aborted) {
+                this.logger.info({ swapId }, 'Poll cancelled');
+                this.transition({ phase: 'cancelled', snapshot: this.flowCtx });
+                return;
+            }
+            tick++;
+            let detail;
+            try {
+                detail = await this.api.getSwapDetail(swapId);
+            }
+            catch {
+                continue;
+            }
+            if (detail.verification && !this.flowCtx?.verification?.verified) {
+                this.setFlowContext({ verification: {
+                        verified: true,
+                        provider: detail.verification.provider,
+                        checks: [{ name: 'Server verification', passed: true, detail: 'Populated' }],
+                        timestamp: Date.now(),
+                    } });
+            }
+            const mapped = mapServerStatus(detail.status);
+            const pollKey = `${detail.status}|${mapped ?? ''}`;
+            if (pollKey !== this.lastPollKey) {
+                this.logger.debug({ swapId, serverStatus: detail.status, mappedStage: mapped, tick }, 'Poll tick');
+                this.lastPollKey = pollKey;
+            }
+            if (TERMINAL_STATUSES.has(detail.status)) {
+                this.logger.info({ swapId, status: detail.status }, 'Poll detected terminal status');
+                this.emitTerminalFromDetail(detail);
+                return;
+            }
+            if (!mapped)
+                continue;
+            switch (detail.status) {
+                case 'deposited': {
+                    this.setFlowContext({ extra: { text: 'Confirming deposit...', type: 'message' } });
+                    const v = this.requireVerified('confirming');
+                    if (v)
+                        this.transition({ phase: 'confirming', snapshot: v, requiredAction: detail.requiredAction ?? null });
+                    break;
+                }
+                case 'swapping': {
+                    this.setFlowContext({ extra: { text: 'Swapping...', type: 'message' } });
+                    const v = this.requireVerified('swapping');
+                    if (v)
+                        this.transition({ phase: 'swapping', snapshot: v, requiredAction: detail.requiredAction ?? null });
+                    break;
+                }
+                case 'cancelling': {
+                    // Atomicswap cancel path. Emit the dedicated `cancelling` phase so
+                    // the UI can render "TxCancel broadcast, waiting for refund" text
+                    // without pretending the swap is still making forward progress.
+                    const msg = detail.requiredAction?.message ??
+                        'Swap is cancelling — refund in progress. Waiting for terminal status.';
+                    this.setFlowContext({ extra: { text: msg, type: 'message' } });
+                    const v = this.requireVerified('cancelling');
+                    if (v) {
+                        this.transition({
+                            phase: 'cancelling',
+                            snapshot: v,
+                            requiredAction: detail.requiredAction ?? null,
+                        });
+                    }
+                    break;
+                }
+                case 'sending': {
+                    this.setFlowContext({ extra: { text: 'Sending output...', type: 'message' } });
+                    const v = this.requireVerified('sending');
+                    if (v)
+                        this.transition({ phase: 'sending', snapshot: v });
+                    break;
+                }
+                default: break;
+            }
+        }
+    }
+    emitTerminal(detail, fromToken, toToken) {
+        this.setFlowContext({
+            swapId: detail.swapNumber,
+            swapNumber: detail.swapNumber,
+            fromToken,
+            toToken,
+            depositAmount: detail.amountIn,
+        });
+        switch (detail.status) {
+            case 'completed':
+                this.setFlowContext({ extra: { text: 'Swap completed', type: 'message' } });
+                this.transition({
+                    phase: 'completed',
+                    snapshot: this.flowCtx,
+                    actualOut: detail.actualAmountOut ?? '',
+                    outputTxHash: detail.outputTxHash ?? null,
+                    durationSec: detail.durationSeconds ?? null,
+                });
+                return;
+            case 'refunded':
+                this.setFlowContext({
+                    extra: { text: 'BTC refunded to your address.', type: 'message' },
+                });
+                this.transition({
+                    phase: 'refunded',
+                    snapshot: this.flowCtx,
+                    refundTxid: detail.refundTxHash ?? null,
+                    actualOut: detail.actualAmountOut ?? '',
+                    durationSec: detail.durationSeconds ?? null,
+                });
+                return;
+            case 'punished':
+                this.setFlowContext({
+                    extra: { text: 'Refund deadline missed — BTC was punished.', type: 'error' },
+                });
+                this.transition({ phase: 'punished', snapshot: this.flowCtx });
+                return;
+            case 'expired':
+                this.setFlowContext({ extra: { text: 'Swap expired.', type: 'error' } });
+                this.transition({ phase: 'expired', snapshot: this.flowCtx });
+                return;
+            default:
+                this.setFlowContext({
+                    extra: { text: `Swap ended: ${detail.status}`, type: 'error' },
+                });
+                this.transition({
+                    phase: 'failed',
+                    snapshot: this.flowCtx,
+                    error: `Swap ended with status: ${detail.status}`,
+                });
+        }
+    }
+    emitTerminalFromDetail(detail) {
+        this.emitTerminal(detail, detail.fromToken, detail.toToken);
+    }
+    checkAborted() {
+        if (this.signal.aborted) {
+            this.transition({ phase: 'cancelled', snapshot: this.flowCtx });
+            throw new SwapFlowCancelledError();
+        }
+    }
+    handleError(err) {
+        if (err instanceof SwapFlowCancelledError || this.signal.aborted) {
+            this.logger.info({ swapId: this.flowCtx?.swapId ?? null }, 'SwapFlow cancelled');
+            this.transition({ phase: 'cancelled', snapshot: this.flowCtx });
+            return;
+        }
+        const rawMessage = err instanceof Error ? err.message : String(err);
+        const userMessage = humanizeApiError(err);
+        this.logger.error({ swapId: this.flowCtx?.swapId ?? null, error: rawMessage }, 'SwapFlow error');
+        this.setFlowContext({ extra: { text: userMessage, type: 'error' } });
+        this.transition({
+            phase: 'failed', snapshot: this.flowCtx,
+            error: userMessage,
+        });
+    }
+}
+class SwapFlowCancelledError extends Error {
+    constructor() { super('Swap flow cancelled'); this.name = 'SwapFlowCancelledError'; }
+}
+//# sourceMappingURL=swap-flow.js.map