@stelis/say-ur-intent 0.0.0 → 0.0.2

package/dist/adapters/flowx/flowxSwapReviewEvidence.js

@@ -0,0 +1,468 @@
+import { flowxSwapActionPlanDataSchema } from "./flowxSwapIntent.js";
+import { deriveFlowxSwapQuotePolicy } from "./flowxSwapQuotePolicy.js";
+import { flowxSwapReviewLifecycleStageLabel, newFlowxSwapReviewLifecycle } from "./flowxSwapReviewLifecycle.js";
+import { createSwapQuotePolicyEvidence } from "../../core/action/swapQuotePolicyEvidence.js";
+import { publicHumanReadableReviewFromEvidence } from "../../core/action/humanReadableReviewEvidence.js";
+import { publicTransactionSimulationSummaryFromEvidence } from "../../core/action/reviewTimeSimulationEvidence.js";
+import { parseQuoteDisplayAmount } from "../../core/read/deepbookReadHelpers.js";
+import { validateFlowxRouteQuote } from "../../core/read/flowxReadHelpers.js";
+import { FLOWX_CLMM_UNIT_SOURCE, resolveFlowxSwapPair } from "../../core/read/flowxRegistry.js";
+import { ReadServiceInputError } from "../../core/read/readServiceTypes.js";
+import { blockedAdapterLifecycleReviewResult, failReviewCheck, passReviewCheck, producerStageMissingReviewResult, refreshRequiredAdapterLifecycleReviewResult, walletReviewContractEmitMissingResult, walletReviewContractEmittedResult } from "../../core/review/reviewComputationResult.js";
+import { assembleWalletReviewAdapterContract } from "../../core/action/walletReviewContractAssembler.js";
+export async function computeFlowxSwapReviewEvidence(input) {
+    const lifecycle = newFlowxSwapReviewLifecycle(input.plan);
+    const checks = [];
+    const now = input.now ?? new Date();
+    const intentStage = await runFlowxReviewStage({
+        lifecycle,
+        checks,
+        stage: "intent_normalized",
+        run: () => normalizeIntentStage(input.plan)
+    });
+    if (!intentStage.ok) {
+        return { result: intentStage.result };
+    }
+    const requestedIntent = intentStage.evidence;
+    const pairStage = await runFlowxReviewStage({
+        lifecycle,
+        checks,
+        stage: "pair_resolved",
+        run: () => resolvePairStage(requestedIntent)
+    });
+    if (!pairStage.ok) {
+        return { result: pairStage.result };
+    }
+    const pairEvidence = pairStage.evidence;
+    const quoteStage = await runFlowxReviewStage({
+        lifecycle,
+        checks,
+        stage: "quote_evidence_fetched",
+        run: () => quoteEvidenceStage(input, requestedIntent, pairEvidence)
+    });
+    if (!quoteStage.ok) {
+        return { result: quoteStage.result };
+    }
+    const quoteEvidence = quoteStage.evidence;
+    const policyStage = await runFlowxReviewStage({
+        lifecycle,
+        checks,
+        stage: "quote_policy_derived",
+        run: () => quotePolicyStage(requestedIntent, quoteEvidence, now)
+    });
+    if (!policyStage.ok) {
+        return { result: policyStage.result };
+    }
+    const quotePolicy = policyStage.evidence;
+    if (!input.transactionMaterialProducer) {
+        return { result: missingProducerStageBlockedResult(lifecycle.snapshot(), checks) };
+    }
+    const materialStage = await runFlowxReviewStage({
+        lifecycle,
+        checks,
+        stage: "transaction_material_build_or_verify",
+        run: () => input.transactionMaterialProducer({
+            reviewSessionId: input.reviewSessionId,
+            plan: input.plan,
+            account: input.account,
+            requestedIntent,
+            pairEvidence,
+            quoteEvidence,
+            quotePolicy,
+            now
+        })
+    });
+    if (!materialStage.ok) {
+        return { result: materialStage.result };
+    }
+    if (!input.transactionMaterialDigestProducer) {
+        return { result: missingProducerStageBlockedResult(lifecycle.snapshot(), checks) };
+    }
+    const digestStage = await runFlowxReviewStage({
+        lifecycle,
+        checks,
+        stage: "digest_commitment",
+        run: () => input.transactionMaterialDigestProducer({ materialHandle: materialStage.evidence, now })
+    });
+    if (!digestStage.ok) {
+        return { result: digestStage.result };
+    }
+    const routedPool = quoteEvidence.pools[0];
+    if (!routedPool) {
+        checks.push(failReviewCheck("flowx_quote_policy_material_binding_failed", "Quote policy material binding", "FlowX route quote evidence lost its single routed pool before quote policy binding.", "quote"));
+        return { result: blockedAdapterLifecycleReviewResult("amount_mismatch", checks, lifecycle.snapshot()) };
+    }
+    let swapQuotePolicy;
+    try {
+        swapQuotePolicy = createSwapQuotePolicyEvidence({
+            materialHandle: materialStage.evidence,
+            adapterId: input.plan.adapterId,
+            protocol: input.plan.protocol,
+            actionKind: input.plan.actionKind,
+            quoteEvidenceId: `flowx_route_quote:${input.plan.id}`,
+            quoteSource: {
+                provider: input.plan.protocol,
+                poolKey: routedPool.poolKey,
+                direction: quotePolicy.swapXToY ? "base_to_quote" : "quote_to_base",
+                fetchedAt: quotePolicy.fetchedAt,
+                sourceMoveFunction: "universal_router::build"
+            },
+            maxSlippageBps: quotePolicy.maxSlippageBps,
+            staleAfterMs: quotePolicy.staleAfterMs,
+            sourceAmount: flowxQuotePolicyAmount(quotePolicy.sourceAmountRaw, pairEvidence.source),
+            expectedOutput: flowxQuotePolicyAmount(quotePolicy.expectedOutRaw, pairEvidence.target),
+            minimumOutput: flowxQuotePolicyAmount(quotePolicy.minOutRaw, pairEvidence.target),
+            // The FlowX CLMM swap fee is charged inside the pool at the pinned fee
+            // rate and is already reflected in the quoted output, so no separate
+            // fee asset leaves the account.
+            protocolFee: flowxQuotePolicyAmount("0", pairEvidence.source),
+            derivedAt: new Date(Math.max(now.getTime(), Date.parse(quotePolicy.fetchedAt)))
+        });
+    }
+    catch (error) {
+        checks.push(failReviewCheck("flowx_quote_policy_material_binding_failed", "Quote policy material binding", error instanceof Error ? error.message : "FlowX quote policy evidence did not match the stored transaction material.", "quote"));
+        return { result: blockedAdapterLifecycleReviewResult("amount_mismatch", checks, lifecycle.snapshot()) };
+    }
+    const privateArtifacts = {
+        transactionMaterial: materialStage.evidence,
+        transactionMaterialDigest: digestStage.evidence,
+        swapQuotePolicy
+    };
+    let ptbVisualization;
+    if (input.ptbVisualizationProducer) {
+        const rendered = await input.ptbVisualizationProducer({
+            transactionMaterial: materialStage.evidence,
+            transactionMaterialDigest: digestStage.evidence,
+            adapterId: input.plan.adapterId,
+            planId: input.plan.id,
+            now
+        });
+        if (rendered.status === "rendered") {
+            ptbVisualization = rendered.artifact;
+            checks.push(passReviewCheck("flowx_ptb_visualization", "PTB visualization", "Rendered a Mermaid PTB visualization artifact from the stored local transaction material. Visualization only; it is not wallet authorization, not signing data, not signing readiness, and not execution readiness.", "adapter"));
+        }
+        else {
+            checks.push({
+                id: "flowx_ptb_visualization_unavailable",
+                label: "PTB visualization",
+                status: "warning",
+                message: `PTB visualization is unavailable for this review: ${rendered.reason}. The emitted wallet review contract remains valid; visualization is optional review evidence.`,
+                source: "adapter"
+            });
+        }
+    }
+    const withPtb = (result) => ptbVisualization ? { ...result, ptbVisualization } : result;
+    if (!input.transactionObjectOwnershipProducer) {
+        return {
+            result: withPtb(missingProducerStageBlockedResult(lifecycle.snapshot(), checks)),
+            privateArtifacts
+        };
+    }
+    const ownershipStage = await runFlowxReviewStage({
+        lifecycle,
+        checks,
+        stage: "object_ownership",
+        run: () => input.transactionObjectOwnershipProducer({
+            materialHandle: materialStage.evidence,
+            materialDigest: digestStage.evidence,
+            now
+        })
+    });
+    if (!ownershipStage.ok) {
+        return {
+            result: withPtb(ownershipStage.result),
+            ...(ownershipStage.result.status === "refresh_required" ? {} : { privateArtifacts })
+        };
+    }
+    privateArtifacts.transactionObjectOwnership = ownershipStage.evidence;
+    if (!input.humanReadableReviewProducer) {
+        return {
+            result: withPtb(missingProducerStageBlockedResult(lifecycle.snapshot(), checks)),
+            privateArtifacts
+        };
+    }
+    const humanReviewStage = await runFlowxReviewStage({
+        lifecycle,
+        checks,
+        stage: "human_readable_review",
+        run: () => input.humanReadableReviewProducer({
+            plan: input.plan,
+            account: input.account,
+            requestedIntent,
+            pairEvidence,
+            routedPool,
+            quotePolicy,
+            transactionMaterial: materialStage.evidence,
+            transactionMaterialDigest: digestStage.evidence,
+            swapQuotePolicy,
+            transactionObjectOwnership: ownershipStage.evidence,
+            now
+        })
+    });
+    if (!humanReviewStage.ok) {
+        return { result: withPtb(humanReviewStage.result), privateArtifacts };
+    }
+    privateArtifacts.humanReadableReview = humanReviewStage.evidence;
+    if (!input.reviewTimeSimulationProducer) {
+        return {
+            result: withPtb(missingProducerStageBlockedResult(lifecycle.snapshot(), checks, {
+                humanReadableReview: publicHumanReadableReviewFromEvidence(humanReviewStage.evidence)
+            })),
+            privateArtifacts
+        };
+    }
+    const simulationStage = await runFlowxReviewStage({
+        lifecycle,
+        checks,
+        stage: "review_time_simulation",
+        run: () => input.reviewTimeSimulationProducer({
+            transactionMaterial: materialStage.evidence,
+            transactionMaterialDigest: digestStage.evidence,
+            now
+        })
+    });
+    if (!simulationStage.ok) {
+        return {
+            result: withPtb({
+                ...simulationStage.result,
+                humanReadableReview: publicHumanReadableReviewFromEvidence(humanReviewStage.evidence)
+            }),
+            privateArtifacts
+        };
+    }
+    privateArtifacts.reviewTimeSimulation = simulationStage.evidence;
+    const assembly = assembleWalletReviewAdapterContract({
+        adapterId: input.plan.adapterId,
+        protocol: input.plan.protocol,
+        actionKind: input.plan.actionKind,
+        provenance: {
+            kind: "mcp_action_request",
+            sourceId: input.plan.id,
+            capturedAt: input.plan.createdAt
+        },
+        quotePolicy: swapQuotePolicy,
+        objectOwnership: ownershipStage.evidence,
+        humanReadableReview: humanReviewStage.evidence,
+        reviewTimeSimulation: simulationStage.evidence,
+        transactionMaterialCommitment: digestStage.evidence.transactionDigest,
+        now
+    });
+    if (assembly.status === "emitted") {
+        checks.push(passReviewCheck("flowx_wallet_review_contract_emitted", "Wallet review contract emit", "FlowX account-bound review assembled and schema-validated a wallet review contract from verified review evidence. The local review page can now request the digest-gated handoff for user-controlled wallet signing; MCP output stays free of signing data.", "adapter"));
+        return {
+            result: walletReviewContractEmittedResult(checks, lifecycle.snapshot(), publicHumanReadableReviewFromEvidence(humanReviewStage.evidence), publicTransactionSimulationSummaryFromEvidence(simulationStage.evidence), assembly.contract, ptbVisualization),
+            privateArtifacts
+        };
+    }
+    checks.push(failReviewCheck("flowx_wallet_review_contract_emit_missing", "Wallet review contract emit", `FlowX account-bound review could not assemble the wallet review contract from the current review evidence: ${assembly.reason}. Signing stays blocked.`, "adapter"));
+    return {
+        result: walletReviewContractEmitMissingResult(checks, lifecycle.snapshot(), publicHumanReadableReviewFromEvidence(humanReviewStage.evidence), publicTransactionSimulationSummaryFromEvidence(simulationStage.evidence)),
+        privateArtifacts
+    };
+}
+async function runFlowxReviewStage(input) {
+    const outcome = await input.run();
+    input.checks.push(...outcome.checks);
+    if (outcome.status === "completed") {
+        input.lifecycle.complete(input.stage);
+        return { ok: true, evidence: outcome.evidence };
+    }
+    const adapterLifecycle = input.lifecycle.snapshot();
+    if (outcome.status === "blocked") {
+        return {
+            ok: false,
+            result: blockedAdapterLifecycleReviewResult(outcome.blockedReason, input.checks, adapterLifecycle)
+        };
+    }
+    return {
+        ok: false,
+        result: refreshRequiredAdapterLifecycleReviewResult(outcome.refreshReason, input.checks, adapterLifecycle)
+    };
+}
+function normalizeIntentStage(plan) {
+    const parsedData = flowxSwapActionPlanDataSchema.safeParse(plan.adapterData);
+    if (!parsedData.success) {
+        return {
+            status: "blocked",
+            blockedReason: "unsupported_action",
+            checks: [
+                failReviewCheck("flowx_requested_intent_invalid", "Requested FlowX intent", "The action plan does not contain a valid FlowX swap display intent.", "adapter")
+            ]
+        };
+    }
+    const requestedIntent = parsedData.data.requestedIntent;
+    return {
+        status: "completed",
+        evidence: requestedIntent,
+        checks: [
+            passReviewCheck("flowx_display_intent", "Display intent", `Requested display intent is ${requestedIntent.from.amountDisplay} ${requestedIntent.from.symbol} to ${requestedIntent.to.symbol} with max slippage ${requestedIntent.maxSlippageBps} bps. This display amount is not signing input.`, "adapter")
+        ]
+    };
+}
+function resolvePairStage(requestedIntent) {
+    try {
+        const resolution = resolveFlowxSwapPair({
+            sourceSymbol: requestedIntent.from.symbol,
+            targetSymbol: requestedIntent.to.symbol
+        });
+        const evidence = {
+            source: resolution.source,
+            target: resolution.target,
+            swapXToY: resolution.swapXToY,
+            pinnedPoolCount: resolution.pools.length
+        };
+        return {
+            status: "completed",
+            evidence,
+            checks: [
+                passReviewCheck("flowx_pair_resolution", "FlowX pair", `Resolved pinned FlowX pair ${resolution.source.symbol} to ${resolution.target.symbol} (${resolution.pools.length} pinned fee-tier pools; direction ${resolution.swapXToY ? "x_to_y" : "y_to_x"}). The pool used by the swap is chosen by the FlowX router and verified against this pinned set at quote time.`, "registry")
+            ]
+        };
+    }
+    catch (error) {
+        return {
+            status: "blocked",
+            blockedReason: "asset_mismatch",
+            checks: [
+                failReviewCheck("flowx_pair_resolution_failed", "FlowX pair", error instanceof Error ? error.message : "FlowX pair resolution failed.", "registry")
+            ]
+        };
+    }
+}
+async function quoteEvidenceStage(input, requestedIntent, pairEvidence) {
+    try {
+        const amountInRaw = parseQuoteDisplayAmount(requestedIntent.from.amountDisplay, pairEvidence.source.decimals);
+        const fetched = await input.quoteSource.getSwapRoutesForBuild({
+            tokenInType: pairEvidence.source.coinType,
+            tokenOutType: pairEvidence.target.coinType,
+            amountInRaw
+        });
+        const { pools } = validateFlowxRouteQuote({
+            pair: {
+                source: pairEvidence.source,
+                target: pairEvidence.target,
+                swapXToY: pairEvidence.swapXToY,
+                pools: []
+            },
+            requestedAmountInRaw: amountInRaw,
+            quote: fetched.normalized
+        });
+        const evidence = {
+            amountInRaw,
+            amountOutRaw: fetched.normalized.amountOutRaw,
+            swapXToY: pairEvidence.swapXToY,
+            pools,
+            sdkRoutes: fetched.sdkRoutes,
+            fetchedAt: fetched.fetchedAt
+        };
+        return {
+            status: "completed",
+            evidence,
+            checks: [
+                passReviewCheck("flowx_route_quote_evidence", "Route quote evidence", `Fetched a FlowX route quote at ${fetched.fetchedAt}: expected output before slippage is ${evidence.amountOutRaw} ${pairEvidence.target.symbol} raw units through pinned pool ${pools.map((pool) => pool.poolKey).join(", ")}. The route was chosen by the FlowX router, not by this review; the review verified the routed pool, direction, fee, and protocol config against the pinned registry.`, "quote")
+            ]
+        };
+    }
+    catch (error) {
+        return quoteSourceFailureOutcome(error);
+    }
+}
+function quotePolicyStage(requestedIntent, quoteEvidence, now) {
+    let policy;
+    try {
+        policy = deriveFlowxSwapQuotePolicy({
+            amountInRaw: quoteEvidence.amountInRaw,
+            amountOutRaw: quoteEvidence.amountOutRaw,
+            swapXToY: quoteEvidence.swapXToY,
+            fetchedAt: quoteEvidence.fetchedAt,
+            maxSlippageBps: requestedIntent.maxSlippageBps,
+            now
+        });
+    }
+    catch (error) {
+        return {
+            status: "blocked",
+            blockedReason: "amount_mismatch",
+            checks: [
+                failReviewCheck("flowx_quote_policy_invalid", "Quote policy", error instanceof Error ? error.message : "FlowX quote policy could not be derived.", "quote")
+            ]
+        };
+    }
+    if (policy.status === "refresh_required") {
+        return {
+            status: "refresh_required",
+            refreshReason: policy.refreshReason,
+            checks: [
+                failReviewCheck("flowx_quote_policy_refresh_required", "Quote policy", `Quote policy requires refresh: ${policy.reason}. Quote age is ${policy.quoteAgeMs}ms with stale threshold ${policy.staleAfterMs}ms.`, "quote")
+            ]
+        };
+    }
+    return {
+        status: "completed",
+        evidence: policy,
+        checks: [
+            passReviewCheck("flowx_quote_policy", "Quote policy", `Derived review policy from route quote evidence: sourceAmountRaw ${policy.sourceAmountRaw}, expectedOutRaw ${policy.expectedOutRaw}, minOutRaw ${policy.minOutRaw} (router slippage ${policy.routerSlippageUnits} on the 1e6 scale), deadline ${new Date(policy.deadlineMsEpoch).toISOString()}, quoteAgeMs ${policy.quoteAgeMs}. The router enforces the minimum output on chain at settle; these values are review evidence only and are not transaction bytes, signing data, or signing readiness.`, "quote")
+        ]
+    };
+}
+function flowxQuotePolicyAmount(raw, asset) {
+    return {
+        raw,
+        asset: {
+            symbol: asset.symbol,
+            coinType: asset.coinType,
+            decimals: asset.decimals,
+            unitSource: FLOWX_CLMM_UNIT_SOURCE
+        }
+    };
+}
+function quoteSourceFailureOutcome(error) {
+    const checks = [
+        failReviewCheck("flowx_quote_source_failed", "Quote source", error instanceof Error ? error.message : "FlowX quote source failed.", "quote")
+    ];
+    if (error instanceof ReadServiceInputError) {
+        if (error.kind === "input_invalid") {
+            return { status: "blocked", blockedReason: "amount_mismatch", checks };
+        }
+        if (error.kind === "registry_miss") {
+            return { status: "blocked", blockedReason: "asset_mismatch", checks };
+        }
+        if (error.kind === "quote_unavailable") {
+            return { status: "refresh_required", refreshReason: "quote_unavailable", checks };
+        }
+    }
+    return { status: "blocked", blockedReason: "object_resolution_failed", checks };
+}
+function missingProducerStageCheck(adapterLifecycle) {
+    const nextMissing = adapterLifecycle.missingStages[0];
+    if (nextMissing === undefined) {
+        return contractEmitMissingCheck();
+    }
+    const nextMissingLabel = flowxSwapReviewLifecycleStageLabel(nextMissing);
+    return {
+        id: `flowx_${nextMissing}_missing`,
+        label: nextMissingLabel,
+        status: "fail",
+        message: `FlowX account-bound review has not completed ${nextMissingLabel}. This is required before wallet handoff, signing, or execution, and no transaction bytes or signing readiness are available.`,
+        source: "adapter"
+    };
+}
+function missingProducerStageBlockedResult(adapterLifecycle, checks, fields = {}) {
+    const nextMissing = adapterLifecycle.missingStages[0];
+    if (nextMissing === undefined) {
+        if (!fields.humanReadableReview || !fields.simulation) {
+            throw new Error("wallet_review_contract_emit_missing requires human-readable review and simulation public evidence");
+        }
+        return walletReviewContractEmitMissingResult([...checks, contractEmitMissingCheck()], adapterLifecycle, fields.humanReadableReview, fields.simulation);
+    }
+    return producerStageMissingReviewResult([...checks, missingProducerStageCheck(adapterLifecycle)], adapterLifecycle, fields.humanReadableReview ? { humanReadableReview: fields.humanReadableReview } : {});
+}
+function contractEmitMissingCheck() {
+    return {
+        id: "flowx_wallet_review_contract_emit_missing",
+        label: "Wallet review contract emit",
+        status: "fail",
+        message: "FlowX account-bound review completed review-time simulation, but this review did not assemble a wallet review contract, so signing stays blocked for this session.",
+        source: "adapter"
+    };
+}

package/dist/adapters/flowx/flowxSwapReviewLifecycle.js

@@ -0,0 +1,85 @@
+import { z } from "zod";
+import { FLOWX_SWAP_ACTION_KIND, FLOWX_SWAP_ADAPTER_ID, FLOWX_SWAP_PROTOCOL } from "./flowxSwapIntent.js";
+export const FLOWX_SWAP_REVIEW_LIFECYCLE_STAGE_CATALOG_ID = "flowx_swap_review_v1";
+export const FLOWX_SWAP_REVIEW_LIFECYCLE_STAGES = [
+    "intent_normalized",
+    "pair_resolved",
+    "quote_evidence_fetched",
+    "quote_policy_derived",
+    "transaction_material_build_or_verify",
+    "digest_commitment",
+    "object_ownership",
+    "human_readable_review",
+    "review_time_simulation"
+];
+export const flowxSwapReviewLifecycleStageSchema = z.enum(FLOWX_SWAP_REVIEW_LIFECYCLE_STAGES);
+export const flowxSwapReviewLifecycleSchema = z.object({
+    stageCatalogId: z.literal(FLOWX_SWAP_REVIEW_LIFECYCLE_STAGE_CATALOG_ID),
+    adapterId: z.literal(FLOWX_SWAP_ADAPTER_ID),
+    protocol: z.literal(FLOWX_SWAP_PROTOCOL),
+    actionKind: z.literal(FLOWX_SWAP_ACTION_KIND),
+    completedStages: z.array(flowxSwapReviewLifecycleStageSchema),
+    missingStages: z.array(flowxSwapReviewLifecycleStageSchema)
+}).strict().superRefine((lifecycle, ctx) => {
+    const expectedCompleted = FLOWX_SWAP_REVIEW_LIFECYCLE_STAGES.slice(0, lifecycle.completedStages.length);
+    const expectedMissing = FLOWX_SWAP_REVIEW_LIFECYCLE_STAGES.slice(lifecycle.completedStages.length);
+    if (!sameStringArray(lifecycle.completedStages, expectedCompleted)) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["completedStages"],
+            message: "completedStages must be the canonical FlowX swap review lifecycle prefix"
+        });
+    }
+    if (!sameStringArray(lifecycle.missingStages, expectedMissing)) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["missingStages"],
+            message: "missingStages must be the canonical FlowX swap review lifecycle remainder"
+        });
+    }
+});
+const FLOWX_SWAP_REVIEW_STAGE_LABELS = {
+    intent_normalized: "Intent normalized",
+    pair_resolved: "FlowX pair resolved",
+    quote_evidence_fetched: "FlowX route quote fetched",
+    quote_policy_derived: "Quote policy derived",
+    transaction_material_build_or_verify: "Transaction material build or verify",
+    digest_commitment: "Digest commitment",
+    object_ownership: "Object ownership",
+    human_readable_review: "Human-readable review",
+    review_time_simulation: "Review-time simulation"
+};
+export function newFlowxSwapReviewLifecycle(plan) {
+    const completedStages = [];
+    return {
+        complete(stage) {
+            const expectedStage = FLOWX_SWAP_REVIEW_LIFECYCLE_STAGES[completedStages.length];
+            if (stage !== expectedStage) {
+                throw new Error(`FlowX swap review lifecycle stage '${stage}' cannot complete before '${expectedStage ?? "none"}'.`);
+            }
+            completedStages.push(stage);
+        },
+        snapshot() {
+            return flowxSwapReviewLifecycleSchema.parse({
+                stageCatalogId: FLOWX_SWAP_REVIEW_LIFECYCLE_STAGE_CATALOG_ID,
+                adapterId: plan.adapterId,
+                protocol: plan.protocol,
+                actionKind: plan.actionKind,
+                completedStages: [...completedStages],
+                missingStages: FLOWX_SWAP_REVIEW_LIFECYCLE_STAGES.filter((stage) => !completedStages.includes(stage))
+            });
+        }
+    };
+}
+export function flowxSwapReviewLifecycleStageLabel(stage) {
+    return FLOWX_SWAP_REVIEW_STAGE_LABELS[stage];
+}
+export function validateFlowxSwapReviewLifecycle(lifecycle) {
+    flowxSwapReviewLifecycleSchema.parse(lifecycle);
+}
+function sameStringArray(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((value, index) => value === right[index]);
+}