@waiaas/daemon 2.0.0-rc.1

package/dist/pipeline/stages.js

@@ -0,0 +1,784 @@
+/**
+ * 6-stage transaction pipeline stages.
+ *
+ * Stage 1: Validate request + INSERT PENDING transaction (with sessionId audit trail)
+ * Stage 2: Auth (sessionId passthrough from route handler)
+ * Stage 3: Policy evaluation (evaluateAndReserve TOCTOU-safe + downgradeIfNoOwner)
+ * Stage 4: Wait (v1.1 passthrough, INSTANT tier only)
+ * Stage 5: On-chain execution (build -> simulate -> sign -> submit)
+ * Stage 6: Confirmation wait
+ *
+ * @see docs/32-pipeline-design.md
+ */
+import { eq } from 'drizzle-orm';
+import { WAIaaSError, ChainError, SendTransactionRequestSchema, TransactionRequestSchema, } from '@waiaas/core';
+import { wallets, transactions, auditLog } from '../infrastructure/database/schema.js';
+import { generateId } from '../infrastructure/database/id.js';
+import { DatabasePolicyEngine } from './database-policy-engine.js';
+import { downgradeIfNoOwner } from '../workflow/owner-state.js';
+import { formatDisplayCurrency } from '@waiaas/core';
+import { resolveEffectiveAmountUsd } from './resolve-effective-amount-usd.js';
+import { sleep } from './sleep.js';
+// v1.5: CoinGecko 키 안내 힌트 최초 1회 추적 (데몬 재시작 시 리셋 OK)
+const hintedTokens = new Set();
+// Exported for test cleanup
+export { hintedTokens };
+// ---------------------------------------------------------------------------
+// Helper: safe request field accessors for union type
+// ---------------------------------------------------------------------------
+/** Safely extract `amount` from SendTransactionRequest | TransactionRequest. */
+function getRequestAmount(req) {
+    if ('amount' in req && typeof req.amount === 'string')
+        return req.amount;
+    return '0';
+}
+/** Safely extract `to` from SendTransactionRequest | TransactionRequest. */
+function getRequestTo(req) {
+    if ('to' in req && typeof req.to === 'string')
+        return req.to;
+    return '';
+}
+/** Safely extract `memo` from SendTransactionRequest | TransactionRequest. */
+function getRequestMemo(req) {
+    if ('memo' in req && typeof req.memo === 'string')
+        return req.memo;
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Helper: resolve display amount for notification messages
+// ---------------------------------------------------------------------------
+/**
+ * Convert amountUsd to display currency string for notification variables.
+ * Returns empty string on failure (graceful fallback -- no display_amount in message).
+ */
+async function resolveDisplayAmount(amountUsd, settingsService, forexRateService) {
+    if (!amountUsd || !settingsService || !forexRateService)
+        return '';
+    try {
+        const currency = settingsService.get('display.currency') ?? 'USD';
+        if (currency === 'USD')
+            return `($${amountUsd.toFixed(2)})`;
+        const rate = await forexRateService.getRate(currency);
+        if (!rate)
+            return `($${amountUsd.toFixed(2)})`;
+        return `(${formatDisplayCurrency(amountUsd, currency, rate.rate)})`;
+    }
+    catch {
+        return '';
+    }
+}
+// ---------------------------------------------------------------------------
+// Helper: extract policy type from evaluation reason string
+// ---------------------------------------------------------------------------
+function extractPolicyType(reason) {
+    if (!reason)
+        return '';
+    if (reason.includes('not in allowed list') || reason.includes('Token transfer not allowed'))
+        return 'ALLOWED_TOKENS';
+    if (reason.includes('not whitelisted') || reason.includes('Contract calls disabled'))
+        return 'CONTRACT_WHITELIST';
+    if (reason.includes('Method not whitelisted'))
+        return 'METHOD_WHITELIST';
+    if (reason.includes('not in approved list') || reason.includes('Token approvals disabled'))
+        return 'APPROVED_SPENDERS';
+    if (reason.includes('not in whitelist') || reason.includes('not in allowed addresses'))
+        return 'WHITELIST';
+    if (reason.includes('not in allowed networks'))
+        return 'ALLOWED_NETWORKS';
+    if (reason.includes('exceeds limit') || reason.includes('Unlimited token approval'))
+        return 'APPROVE_AMOUNT_LIMIT';
+    if (reason.includes('Spending limit'))
+        return 'SPENDING_LIMIT';
+    return '';
+}
+function buildTransactionParam(req, txType, chain) {
+    switch (txType) {
+        case 'TOKEN_TRANSFER': {
+            const r = req;
+            return {
+                type: 'TOKEN_TRANSFER',
+                amount: r.amount,
+                toAddress: r.to,
+                chain,
+                tokenAddress: r.token.address,
+            };
+        }
+        case 'CONTRACT_CALL': {
+            const r = req;
+            return {
+                type: 'CONTRACT_CALL',
+                amount: r.value ?? '0',
+                toAddress: r.to,
+                chain,
+                contractAddress: r.to,
+                selector: r.calldata?.slice(0, 10),
+            };
+        }
+        case 'APPROVE': {
+            const r = req;
+            return {
+                type: 'APPROVE',
+                amount: r.amount,
+                toAddress: r.spender,
+                chain,
+                spenderAddress: r.spender,
+                approveAmount: r.amount,
+            };
+        }
+        case 'TRANSFER':
+        default: {
+            const r = req;
+            return {
+                type: 'TRANSFER',
+                amount: r.amount,
+                toAddress: r.to,
+                chain,
+            };
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Stage 1: Validate + DB INSERT
+// ---------------------------------------------------------------------------
+export async function stage1Validate(ctx) {
+    // Validate request with appropriate Zod schema
+    // If request has a `type` field, use discriminatedUnion schema (5-type)
+    // Otherwise, use legacy SendTransactionRequestSchema (backward compat)
+    const req = ctx.request;
+    if ('type' in req && req.type) {
+        TransactionRequestSchema.parse(req);
+    }
+    else {
+        SendTransactionRequestSchema.parse(req);
+    }
+    // Determine transaction type from request
+    const txType = ('type' in req && req.type) ? req.type : 'TRANSFER';
+    // Generate transaction ID
+    ctx.txId = generateId();
+    // INSERT PENDING transaction into DB
+    const now = new Date(Math.floor(Date.now() / 1000) * 1000);
+    // Extract common and type-specific fields for DB INSERT
+    const amount = 'amount' in req ? req.amount : undefined;
+    const toAddress = 'to' in req ? req.to : undefined;
+    await ctx.db.insert(transactions).values({
+        id: ctx.txId,
+        walletId: ctx.walletId,
+        chain: ctx.wallet.chain,
+        network: ctx.resolvedNetwork,
+        type: txType,
+        status: 'PENDING',
+        amount: amount ?? null,
+        toAddress: toAddress ?? null,
+        sessionId: ctx.sessionId ?? null,
+        createdAt: now,
+    });
+    // Fire-and-forget: notify TX_REQUESTED (never blocks pipeline)
+    // display_amount is empty at Stage 1 -- amountUsd not yet computed
+    void ctx.notificationService?.notify('TX_REQUESTED', ctx.walletId, {
+        amount: amount ?? '0',
+        to: toAddress ?? '',
+        type: txType,
+        display_amount: '',
+    }, { txId: ctx.txId });
+    // v1.6: emit wallet:activity TX_REQUESTED event
+    ctx.eventBus?.emit('wallet:activity', {
+        walletId: ctx.walletId,
+        activity: 'TX_REQUESTED',
+        details: { txId: ctx.txId },
+        timestamp: Math.floor(Date.now() / 1000),
+    });
+}
+// ---------------------------------------------------------------------------
+// Stage 2: Auth (v1.1 passthrough)
+// ---------------------------------------------------------------------------
+export async function stage2Auth(_ctx) {
+    // sessionId is set on PipelineContext by the route handler from Hono c.get('sessionId').
+    // In v1.2 this stage validates session is still active.
+    // For now, the sessionAuth middleware already validated the JWT and set sessionId.
+}
+// ---------------------------------------------------------------------------
+// Stage 3: Policy evaluation
+// ---------------------------------------------------------------------------
+export async function stage3Policy(ctx) {
+    let evaluation;
+    // Determine transaction type from request
+    const req = ctx.request;
+    const txType = ('type' in req && req.type) ? req.type : 'TRANSFER';
+    // Build type-specific TransactionParam (hoisted for notification use)
+    const txParam = buildTransactionParam(req, txType, ctx.wallet.chain);
+    txParam.network = ctx.resolvedNetwork;
+    // [Phase 127] Oracle HTTP 호출 (evaluateAndReserve 진입 전 완료)
+    let priceResult;
+    if (ctx.priceOracle) {
+        priceResult = await resolveEffectiveAmountUsd(req, txType, ctx.wallet.chain, ctx.priceOracle);
+    }
+    // BATCH type uses evaluateBatch (2-stage policy evaluation)
+    if (txType === 'BATCH' && ctx.policyEngine instanceof DatabasePolicyEngine) {
+        const batchReq = req;
+        // Classify each instruction and build TransactionParam array
+        const params = batchReq.instructions.map((instr) => {
+            let instrType = 'TRANSFER';
+            if ('spender' in instr)
+                instrType = 'APPROVE';
+            else if ('token' in instr)
+                instrType = 'TOKEN_TRANSFER';
+            else if ('programId' in instr || 'calldata' in instr)
+                instrType = 'CONTRACT_CALL';
+            return {
+                type: instrType,
+                amount: 'amount' in instr ? instr.amount ?? '0' : '0',
+                toAddress: 'to' in instr ? instr.to ?? '' : '',
+                chain: ctx.wallet.chain,
+                network: ctx.resolvedNetwork,
+                tokenAddress: 'token' in instr ? instr.token?.address : undefined,
+                contractAddress: instrType === 'CONTRACT_CALL' ? ('to' in instr ? instr.to : undefined) : undefined,
+                selector: 'calldata' in instr ? instr.calldata?.slice(0, 10) : undefined,
+                spenderAddress: 'spender' in instr ? instr.spender : undefined,
+                approveAmount: instrType === 'APPROVE' && 'amount' in instr ? instr.amount : undefined,
+            };
+        });
+        // evaluateBatch에 batchUsdAmount 전달 (Phase 127)
+        const batchUsdAmount = priceResult?.type === 'success' ? priceResult.usdAmount : undefined;
+        evaluation = await ctx.policyEngine.evaluateBatch(ctx.walletId, params, batchUsdAmount);
+    }
+    else {
+        // evaluateAndReserve에 usdAmount 전달 (Phase 127)
+        const usdAmount = priceResult?.type === 'success' ? priceResult.usdAmount : undefined;
+        // Use evaluateAndReserve for TOCTOU-safe evaluation when DatabasePolicyEngine + sqlite available
+        if (ctx.policyEngine instanceof DatabasePolicyEngine && ctx.sqlite) {
+            evaluation = ctx.policyEngine.evaluateAndReserve(ctx.walletId, txParam, ctx.txId, usdAmount);
+        }
+        else {
+            evaluation = await ctx.policyEngine.evaluate(ctx.walletId, txParam);
+        }
+    }
+    if (!evaluation.allowed) {
+        // Update tx status to CANCELLED (REJECTED not in TRANSACTION_STATUSES enum)
+        await ctx.db
+            .update(transactions)
+            .set({ status: 'CANCELLED', error: evaluation.reason ?? 'Policy denied' })
+            .where(eq(transactions.id, ctx.txId));
+        // Fire-and-forget: notify POLICY_VIOLATION (never blocks pipeline)
+        void ctx.notificationService?.notify('POLICY_VIOLATION', ctx.walletId, {
+            reason: evaluation.reason ?? 'Policy denied',
+            amount: getRequestAmount(ctx.request),
+            to: getRequestTo(ctx.request),
+            policyType: extractPolicyType(evaluation.reason),
+            tokenAddress: txParam.tokenAddress ?? '',
+            contractAddress: txParam.contractAddress ?? '',
+            adminLink: '/admin/policies',
+        }, { txId: ctx.txId });
+        throw new WAIaaSError('POLICY_DENIED', {
+            message: evaluation.reason ?? 'Transaction denied by policy',
+        });
+    }
+    let tier = evaluation.tier;
+    let downgraded = false;
+    // [Phase 127] PriceResult에 따른 후처리
+    if (priceResult?.type === 'notListed') {
+        // 감사 로그: UNLISTED_TOKEN_TRANSFER
+        await ctx.db.insert(auditLog).values({
+            timestamp: new Date(Math.floor(Date.now() / 1000) * 1000),
+            eventType: 'UNLISTED_TOKEN_TRANSFER',
+            actor: ctx.sessionId ?? 'system',
+            walletId: ctx.walletId,
+            txId: ctx.txId,
+            details: JSON.stringify({
+                tokenAddress: priceResult.tokenAddress,
+                chain: priceResult.chain,
+                failedCount: priceResult.failedCount,
+            }),
+            severity: 'warning',
+        });
+        // 최소 NOTIFY 격상 (evaluation tier와 NOTIFY 중 보수적)
+        const TIER_ORDER = ['INSTANT', 'NOTIFY', 'DELAY', 'APPROVAL'];
+        const currentIdx = TIER_ORDER.indexOf(tier);
+        const notifyIdx = TIER_ORDER.indexOf('NOTIFY');
+        if (currentIdx < notifyIdx) {
+            tier = 'NOTIFY';
+        }
+        // CoinGecko 키 미설정 + 최초 1회 힌트
+        const cacheKey = `${priceResult.chain}:${priceResult.tokenAddress}`;
+        const coingeckoKey = ctx.settingsService?.get('oracle.coingecko_api_key');
+        const shouldShowHint = !coingeckoKey && !hintedTokens.has(cacheKey);
+        if (shouldShowHint) {
+            hintedTokens.add(cacheKey);
+        }
+        // 가격 불명 토큰 알림 발송 (allowed=true인 상태에서도 notListed는 발생)
+        const hint = shouldShowHint
+            ? 'CoinGecko API 키를 설정하면 이 토큰의 USD 가격을 조회할 수 있습니다. Admin Settings > Oracle에서 설정하세요.'
+            : undefined;
+        const notifyVars = {
+            amount: getRequestAmount(ctx.request),
+            to: getRequestTo(ctx.request),
+            reason: `가격 불명 토큰 (${priceResult.tokenAddress}) -- 최소 NOTIFY 격상`,
+            policyType: 'SPENDING_LIMIT',
+        };
+        if (hint)
+            notifyVars.hint = hint;
+        void ctx.notificationService?.notify('POLICY_VIOLATION', ctx.walletId, notifyVars, { txId: ctx.txId });
+    }
+    // oracleDown: 아무것도 하지 않음 -- 네이티브 금액 기준 tier가 이미 설정됨
+    // Check for APPROVAL -> DELAY downgrade when no owner registered
+    if (tier === 'APPROVAL') {
+        const walletRow = await ctx.db.select().from(wallets).where(eq(wallets.id, ctx.walletId)).get();
+        if (walletRow) {
+            const result = downgradeIfNoOwner({
+                ownerAddress: walletRow.ownerAddress ?? null,
+                ownerVerified: walletRow.ownerVerified ?? false,
+            }, tier);
+            tier = result.tier;
+            downgraded = result.downgraded;
+        }
+    }
+    // Set tier and metadata on context
+    ctx.tier = tier;
+    ctx.downgraded = downgraded;
+    if (evaluation.delaySeconds !== undefined) {
+        ctx.delaySeconds = evaluation.delaySeconds;
+    }
+    // [Phase 139] Cache amountUsd on context for Stage 5/6 display_amount
+    const stageAmountUsd = priceResult?.type === 'success' ? priceResult.usdAmount : undefined;
+    ctx.amountUsd = stageAmountUsd;
+    // [Phase 139] Resolve display amount for notifications
+    const displayAmount = await resolveDisplayAmount(stageAmountUsd ?? null, ctx.settingsService, ctx.forexRateService);
+    // [Phase 136] Cumulative spending warning notification (80% threshold)
+    if (evaluation.cumulativeWarning) {
+        const w = evaluation.cumulativeWarning;
+        void ctx.notificationService?.notify('CUMULATIVE_LIMIT_WARNING', ctx.walletId, {
+            type: w.type,
+            spent: String(w.spent.toFixed(2)),
+            limit: String(w.limit.toFixed(2)),
+            ratio: String(Math.round(w.ratio * 100)),
+            display_amount: displayAmount,
+        }, { txId: ctx.txId });
+    }
+    // [Phase 136] APPROVAL tier notification with reason
+    if (tier === 'APPROVAL' && !downgraded) {
+        const reason = evaluation.approvalReason ?? 'per_tx';
+        void ctx.notificationService?.notify('TX_APPROVAL_REQUIRED', ctx.walletId, {
+            amount: getRequestAmount(ctx.request),
+            to: getRequestTo(ctx.request),
+            reason,
+            display_amount: displayAmount,
+        }, { txId: ctx.txId });
+    }
+    // Update DB with tier
+    await ctx.db
+        .update(transactions)
+        .set({ tier })
+        .where(eq(transactions.id, ctx.txId));
+}
+// ---------------------------------------------------------------------------
+// Stage 4: Wait (DELAY/APPROVAL branching, INSTANT/NOTIFY passthrough)
+// ---------------------------------------------------------------------------
+export async function stage4Wait(ctx) {
+    const tier = ctx.tier;
+    // INSTANT and NOTIFY: pass through to stage5
+    if (tier === 'INSTANT' || tier === 'NOTIFY') {
+        return;
+    }
+    // DELAY: queue with cooldown, halt pipeline
+    if (tier === 'DELAY') {
+        if (!ctx.delayQueue) {
+            // Fallback: if no DelayQueue, treat as INSTANT (backward compat)
+            return;
+        }
+        const delaySeconds = ctx.delaySeconds
+            ?? ctx.config?.policy_defaults_delay_seconds
+            ?? 60;
+        ctx.delayQueue.queueDelay(ctx.txId, delaySeconds);
+        // Halt pipeline -- transaction will be picked up by processExpired worker
+        throw new WAIaaSError('PIPELINE_HALTED', {
+            message: `Transaction ${ctx.txId} queued for ${delaySeconds}s delay`,
+        });
+    }
+    // APPROVAL: create pending approval, halt pipeline
+    if (tier === 'APPROVAL') {
+        if (!ctx.approvalWorkflow) {
+            // Fallback: if no ApprovalWorkflow, treat as INSTANT (backward compat)
+            return;
+        }
+        ctx.approvalWorkflow.requestApproval(ctx.txId);
+        // v1.6.1: fire-and-forget WC signing request (non-blocking)
+        if (ctx.wcSigningBridge) {
+            void ctx.wcSigningBridge.requestSignature(ctx.walletId, ctx.txId, ctx.wallet.chain);
+        }
+        // Halt pipeline -- transaction will be picked up by approve/reject/expire
+        throw new WAIaaSError('PIPELINE_HALTED', {
+            message: `Transaction ${ctx.txId} queued for owner approval`,
+        });
+    }
+}
+// ---------------------------------------------------------------------------
+// Helper: buildByType -- route to correct adapter method based on request.type
+// ---------------------------------------------------------------------------
+/**
+ * Build unsigned transaction by dispatching to the correct IChainAdapter method
+ * based on request.type (TRANSFER/TOKEN_TRANSFER/CONTRACT_CALL/APPROVE/BATCH).
+ */
+async function buildByType(adapter, request, walletPublicKey) {
+    const type = ('type' in request && request.type) || 'TRANSFER';
+    switch (type) {
+        case 'TRANSFER': {
+            return adapter.buildTransaction({
+                from: walletPublicKey,
+                to: getRequestTo(request),
+                amount: BigInt(getRequestAmount(request)),
+                memo: getRequestMemo(request),
+            });
+        }
+        case 'TOKEN_TRANSFER': {
+            const req = request;
+            return adapter.buildTokenTransfer({
+                from: walletPublicKey,
+                to: req.to,
+                amount: BigInt(req.amount),
+                token: req.token,
+                memo: req.memo,
+            });
+        }
+        case 'CONTRACT_CALL': {
+            const req = request;
+            return adapter.buildContractCall({
+                from: walletPublicKey,
+                to: req.to,
+                calldata: req.calldata,
+                abi: req.abi,
+                value: req.value ? BigInt(req.value) : undefined,
+                programId: req.programId,
+                instructionData: req.instructionData
+                    ? Buffer.from(req.instructionData, 'base64')
+                    : undefined,
+                accounts: req.accounts,
+            });
+        }
+        case 'APPROVE': {
+            const req = request;
+            return adapter.buildApprove({
+                from: walletPublicKey,
+                spender: req.spender,
+                token: req.token,
+                amount: BigInt(req.amount),
+            });
+        }
+        case 'BATCH': {
+            const req = request;
+            return adapter.buildBatch({
+                from: walletPublicKey,
+                instructions: req.instructions.map((instr) => {
+                    // Classify by field presence (same logic as classifyInstruction in Phase 80)
+                    if ('spender' in instr) {
+                        const a = instr;
+                        return {
+                            from: walletPublicKey,
+                            spender: a.spender,
+                            token: a.token,
+                            amount: BigInt(a.amount),
+                        };
+                    }
+                    if ('token' in instr) {
+                        const t = instr;
+                        return {
+                            from: walletPublicKey,
+                            to: t.to,
+                            amount: BigInt(t.amount),
+                            token: t.token,
+                            memo: t.memo,
+                        };
+                    }
+                    if ('programId' in instr || 'calldata' in instr) {
+                        const c = instr;
+                        return {
+                            from: walletPublicKey,
+                            to: c.to,
+                            calldata: c.calldata,
+                            programId: c.programId,
+                            instructionData: c.instructionData
+                                ? Buffer.from(c.instructionData, 'base64')
+                                : undefined,
+                            accounts: c.accounts,
+                            value: c.value ? BigInt(c.value) : undefined,
+                        };
+                    }
+                    // Default: TRANSFER instruction
+                    const tr = instr;
+                    return {
+                        from: walletPublicKey,
+                        to: tr.to,
+                        amount: BigInt(tr.amount),
+                        memo: tr.memo,
+                    };
+                }),
+            });
+        }
+        default:
+            throw new WAIaaSError('CHAIN_ERROR', {
+                message: `Unknown transaction type: ${type}`,
+            });
+    }
+}
+// ---------------------------------------------------------------------------
+// Stage 5: On-chain execution (CONC-01 retry loop)
+// ---------------------------------------------------------------------------
+/**
+ * Stage 5: Build -> Simulate -> Sign -> Submit with CONC-01 retry logic.
+ *
+ * ChainError category-based retry:
+ * - PERMANENT: immediate FAILED, no retry
+ * - TRANSIENT: exponential backoff (1s, 2s, 4s), max 3 retries (retryCount >= 3 guard)
+ * - STALE: rebuild from Stage 5a, max 1 (retryCount >= 1 guard)
+ *
+ * retryCount is shared between TRANSIENT and STALE to limit total retry count.
+ * Total attempts: initial 1 + up to 3 retries = 4 max.
+ */
+export async function stage5Execute(ctx) {
+    const reqAmount = getRequestAmount(ctx.request);
+    const reqTo = getRequestTo(ctx.request);
+    // [Phase 139] Resolve display amount once for all Stage 5 notifications
+    const displayAmount = await resolveDisplayAmount(ctx.amountUsd ?? null, ctx.settingsService, ctx.forexRateService);
+    let retryCount = 0;
+    // Outer buildLoop: STALE errors return here to rebuild from Stage 5a
+    buildLoop: while (true) {
+        try {
+            // Stage 5a: Build unsigned transaction (type-routed)
+            ctx.unsignedTx = await buildByType(ctx.adapter, ctx.request, ctx.wallet.publicKey);
+            // Stage 5b: Simulate
+            const simResult = await ctx.adapter.simulateTransaction(ctx.unsignedTx);
+            if (!simResult.success) {
+                await ctx.db
+                    .update(transactions)
+                    .set({ status: 'FAILED', error: simResult.error ?? 'Simulation failed' })
+                    .where(eq(transactions.id, ctx.txId));
+                // Fire-and-forget: notify TX_FAILED on simulation failure
+                void ctx.notificationService?.notify('TX_FAILED', ctx.walletId, {
+                    reason: simResult.error ?? 'Simulation failed',
+                    amount: reqAmount,
+                    display_amount: displayAmount,
+                }, { txId: ctx.txId });
+                // v1.6: emit transaction:failed event (simulation failure)
+                ctx.eventBus?.emit('transaction:failed', {
+                    walletId: ctx.walletId,
+                    txId: ctx.txId,
+                    error: simResult.error ?? 'Simulation failed',
+                    network: ctx.resolvedNetwork,
+                    type: ('type' in ctx.request && ctx.request.type) ? ctx.request.type : 'TRANSFER',
+                    timestamp: Math.floor(Date.now() / 1000),
+                });
+                throw new WAIaaSError('SIMULATION_FAILED', {
+                    message: simResult.error ?? 'Transaction simulation failed',
+                });
+            }
+            // Stage 5c: Decrypt private key, sign
+            // CRITICAL: key MUST be released in finally block
+            let privateKey = null;
+            try {
+                privateKey = await ctx.keyStore.decryptPrivateKey(ctx.walletId, ctx.masterPassword);
+                ctx.signedTx = await ctx.adapter.signTransaction(ctx.unsignedTx, privateKey);
+            }
+            finally {
+                if (privateKey) {
+                    ctx.keyStore.releaseKey(privateKey);
+                }
+            }
+            // Stage 5d: Submit
+            ctx.submitResult = await ctx.adapter.submitTransaction(ctx.signedTx);
+            // Success: Update DB SUBMITTED + txHash
+            await ctx.db
+                .update(transactions)
+                .set({ status: 'SUBMITTED', txHash: ctx.submitResult.txHash })
+                .where(eq(transactions.id, ctx.txId));
+            // Fire-and-forget: notify TX_SUBMITTED
+            void ctx.notificationService?.notify('TX_SUBMITTED', ctx.walletId, {
+                txHash: ctx.submitResult.txHash,
+                amount: reqAmount,
+                to: reqTo,
+                display_amount: displayAmount,
+            }, { txId: ctx.txId });
+            // v1.6: emit wallet:activity TX_SUBMITTED event
+            ctx.eventBus?.emit('wallet:activity', {
+                walletId: ctx.walletId,
+                activity: 'TX_SUBMITTED',
+                details: { txId: ctx.txId, txHash: ctx.submitResult.txHash },
+                timestamp: Math.floor(Date.now() / 1000),
+            });
+            return; // Success -- exit the loop
+        }
+        catch (err) {
+            // Non-ChainError: rethrow as-is (WAIaaSError, validation errors, etc.)
+            if (!(err instanceof ChainError)) {
+                throw err;
+            }
+            // ChainError: category-based retry logic
+            switch (err.category) {
+                case 'PERMANENT': {
+                    // Immediate failure, no retry
+                    await ctx.db
+                        .update(transactions)
+                        .set({ status: 'FAILED', error: err.message })
+                        .where(eq(transactions.id, ctx.txId));
+                    // Fire-and-forget: notify TX_FAILED
+                    void ctx.notificationService?.notify('TX_FAILED', ctx.walletId, {
+                        reason: err.message,
+                        amount: reqAmount,
+                        display_amount: displayAmount,
+                    }, { txId: ctx.txId });
+                    // v1.6: emit transaction:failed event (permanent chain error)
+                    ctx.eventBus?.emit('transaction:failed', {
+                        walletId: ctx.walletId,
+                        txId: ctx.txId,
+                        error: err.message,
+                        network: ctx.resolvedNetwork,
+                        type: ('type' in ctx.request && ctx.request.type) ? ctx.request.type : 'TRANSFER',
+                        timestamp: Math.floor(Date.now() / 1000),
+                    });
+                    throw new WAIaaSError('CHAIN_ERROR', {
+                        message: err.message,
+                        cause: err,
+                    });
+                }
+                case 'TRANSIENT': {
+                    if (retryCount >= 3) {
+                        // Max retries exhausted
+                        await ctx.db
+                            .update(transactions)
+                            .set({ status: 'FAILED', error: `${err.code} (max retries exceeded)` })
+                            .where(eq(transactions.id, ctx.txId));
+                        // Fire-and-forget: notify TX_FAILED
+                        void ctx.notificationService?.notify('TX_FAILED', ctx.walletId, {
+                            reason: `${err.code} (max retries exceeded)`,
+                            amount: reqAmount,
+                            display_amount: displayAmount,
+                        }, { txId: ctx.txId });
+                        // v1.6: emit transaction:failed event (transient max retries)
+                        ctx.eventBus?.emit('transaction:failed', {
+                            walletId: ctx.walletId,
+                            txId: ctx.txId,
+                            error: `${err.code} (max retries exceeded)`,
+                            network: ctx.resolvedNetwork,
+                            type: ('type' in ctx.request && ctx.request.type) ? ctx.request.type : 'TRANSFER',
+                            timestamp: Math.floor(Date.now() / 1000),
+                        });
+                        throw new WAIaaSError('CHAIN_ERROR', {
+                            message: `${err.message} (max retries exceeded)`,
+                            cause: err,
+                        });
+                    }
+                    // Exponential backoff: 1s, 2s, 4s
+                    await sleep(1000 * Math.pow(2, retryCount));
+                    retryCount++;
+                    continue buildLoop; // Retry from Stage 5a (rebuild)
+                }
+                case 'STALE': {
+                    if (retryCount >= 1) {
+                        // Stale retry exhausted (shared retryCount)
+                        await ctx.db
+                            .update(transactions)
+                            .set({ status: 'FAILED', error: `${err.code} (stale retry exhausted)` })
+                            .where(eq(transactions.id, ctx.txId));
+                        // Fire-and-forget: notify TX_FAILED
+                        void ctx.notificationService?.notify('TX_FAILED', ctx.walletId, {
+                            reason: `${err.code} (stale retry exhausted)`,
+                            amount: reqAmount,
+                            display_amount: displayAmount,
+                        }, { txId: ctx.txId });
+                        // v1.6: emit transaction:failed event (stale retry exhausted)
+                        ctx.eventBus?.emit('transaction:failed', {
+                            walletId: ctx.walletId,
+                            txId: ctx.txId,
+                            error: `${err.code} (stale retry exhausted)`,
+                            network: ctx.resolvedNetwork,
+                            type: ('type' in ctx.request && ctx.request.type) ? ctx.request.type : 'TRANSFER',
+                            timestamp: Math.floor(Date.now() / 1000),
+                        });
+                        throw new WAIaaSError('CHAIN_ERROR', {
+                            message: `${err.message} (stale retry exhausted)`,
+                            cause: err,
+                        });
+                    }
+                    // Rebuild from Stage 5a with new blockhash/nonce
+                    retryCount++;
+                    continue buildLoop;
+                }
+                default: {
+                    // Unknown category: treat as permanent
+                    await ctx.db
+                        .update(transactions)
+                        .set({ status: 'FAILED', error: err.message })
+                        .where(eq(transactions.id, ctx.txId));
+                    throw new WAIaaSError('CHAIN_ERROR', {
+                        message: err.message,
+                        cause: err,
+                    });
+                }
+            }
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Stage 6: Confirmation wait
+// ---------------------------------------------------------------------------
+export async function stage6Confirm(ctx) {
+    const reqAmount = getRequestAmount(ctx.request);
+    const reqTo = getRequestTo(ctx.request);
+    // [Phase 139] Resolve display amount for Stage 6 notifications
+    const displayAmount = await resolveDisplayAmount(ctx.amountUsd ?? null, ctx.settingsService, ctx.forexRateService);
+    const result = await ctx.adapter.waitForConfirmation(ctx.submitResult.txHash, 30_000);
+    if (result.status === 'confirmed' || result.status === 'finalized') {
+        // On-chain confirmed
+        const executedAt = new Date(Math.floor(Date.now() / 1000) * 1000);
+        await ctx.db
+            .update(transactions)
+            .set({ status: 'CONFIRMED', executedAt })
+            .where(eq(transactions.id, ctx.txId));
+        // Fire-and-forget: notify TX_CONFIRMED (never blocks pipeline)
+        void ctx.notificationService?.notify('TX_CONFIRMED', ctx.walletId, {
+            txHash: ctx.submitResult.txHash,
+            amount: reqAmount,
+            to: reqTo,
+            display_amount: displayAmount,
+        }, { txId: ctx.txId });
+        // v1.6: emit transaction:completed event
+        ctx.eventBus?.emit('transaction:completed', {
+            walletId: ctx.walletId,
+            txId: ctx.txId,
+            txHash: ctx.submitResult.txHash,
+            amount: getRequestAmount(ctx.request),
+            network: ctx.resolvedNetwork,
+            type: ('type' in ctx.request && ctx.request.type) ? ctx.request.type : 'TRANSFER',
+            timestamp: Math.floor(Date.now() / 1000),
+        });
+    }
+    else if (result.status === 'failed') {
+        // On-chain revert
+        await ctx.db
+            .update(transactions)
+            .set({ status: 'FAILED', error: 'Transaction reverted on-chain' })
+            .where(eq(transactions.id, ctx.txId));
+        // Fire-and-forget: notify TX_FAILED on on-chain revert (never blocks pipeline)
+        void ctx.notificationService?.notify('TX_FAILED', ctx.walletId, {
+            reason: 'Transaction reverted on-chain',
+            amount: reqAmount,
+            display_amount: displayAmount,
+        }, { txId: ctx.txId });
+        // v1.6: emit transaction:failed event (on-chain revert)
+        ctx.eventBus?.emit('transaction:failed', {
+            walletId: ctx.walletId,
+            txId: ctx.txId,
+            error: 'Transaction reverted on-chain',
+            network: ctx.resolvedNetwork,
+            type: ('type' in ctx.request && ctx.request.type) ? ctx.request.type : 'TRANSFER',
+            timestamp: Math.floor(Date.now() / 1000),
+        });
+        throw new WAIaaSError('CHAIN_ERROR', {
+            message: 'Transaction reverted on-chain',
+        });
+    }
+    else {
+        // status === 'submitted': still pending, NOT failed
+        // Keep SUBMITTED status (already set by Stage 5)
+        // Do NOT overwrite to FAILED -- tx may confirm later
+        // No notification: no state change occurred
+    }
+}
+//# sourceMappingURL=stages.js.map