@stridge/kit 0.1.0-alpha.0

package/dist/flows/withdraw/dialog/WithdrawDialog.d.ts

@@ -0,0 +1,103 @@
+import { TxRef } from "../../../shared/driver/types.js";
+import { WithdrawalQuotePayload, WithdrawalSettlementFailurePayload, WithdrawalSettlementPendingPayload, WithdrawalSettlementSuccessPayload } from "../driver/payloads.js";
+import { SubmitWithdrawalInput } from "../driver/types.js";
+import { FailureInfo } from "../../../shared/orchestrator/types.js";
+import { WithdrawStateName } from "../orchestrator/types.js";
+import { WithdrawFormEventCallbacks } from "./WithdrawDialogEventsContext.js";
+import { ErrorInfo } from "react";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/flows/withdraw/dialog/WithdrawDialog.d.ts
+/**
+ * Top-level withdraw dialog. Mounts inside `<KitProvider withdraw={…} />` once at the host's
+ * app root and binds open state to the controller's `state.name !== "closed"`.
+ *
+ * Body switch is keyed off the orchestrator's *effective* state (not logical state) so the
+ * widget the user was looking at stays mounted through the dialog's close animation.
+ *
+ * Three top-level callbacks (`onOpened`, `onClosed`, `onStepChanged`) describe the dialog as a
+ * stateful component. The grouped `events={{ … }}` prop carries the operational lifecycle —
+ * form-level inputs, quote / submit / settlement transitions for the active withdrawal.
+ */
+declare function WithdrawDialog({
+  container,
+  onError,
+  onOpened,
+  onClosed,
+  onStepChanged,
+  events
+}?: WithdrawDialog.Props): _$react_jsx_runtime0.JSX.Element;
+declare namespace WithdrawDialog {
+  interface Props {
+    /**
+     * Element the dialog portals into. Defaults to `document.body` (full-page overlay).
+     * Pass a transformed ancestor with `overflow: clip` — e.g. a mobile mockup frame — to
+     * scope the dialog's width, height, and backdrop to that rect.
+     */
+    container?: HTMLElement | null;
+    /** Forwarded to the dialog's internal {@link GatewayKitBoundary} for crash reporting. */
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+    /**
+     * Fires once when the dialog transitions from `closed` to any open step. The withdraw
+     * flow has no `open({ method })` overload — `onOpened` carries no payload.
+     */
+    onOpened?: () => void;
+    /** Fires once when the dialog transitions back to `closed`. `atStep` is the last open step. */
+    onClosed?: (atStep: WithdrawStateName) => void;
+    /** Fires on every logical step transition. */
+    onStepChanged?: (event: {
+      from: WithdrawStateName;
+      to: WithdrawStateName;
+    }) => void;
+    /**
+     * Operational events — user actions, quote / submit / settlement transitions for the
+     * active withdrawal. Each callback is optional and fires after the controller has acted
+     * (state machine has transitioned, driver entity has settled), so payloads are guaranteed
+     * valid for the named event.
+     */
+    events?: Events;
+  }
+  /**
+   * Operational lifecycle hooks. Splits cleanly into:
+   *
+   * - **Form-level inputs** (`onRecipientChanged` / `onAmountChanged` / `onReceiveTokenChanged`
+   *   / `onReceiveChainChanged`) — fire on every change of the form's local state.
+   * - **User actions** (`onWithdrawalConfirmed`) — fire when the user submits the form.
+   * - **Quote lifecycle** — track the form's quote entity through `loading → ready / error`.
+   * - **Submit lifecycle** — track the wagmi-driven broadcast through wagmi → receipt → terminal
+   *   verdict.
+   * - **Settlement entity** — track the gateway's settlement payload through pending / succeeded /
+   *   failed.
+   */
+  interface Events extends WithdrawFormEventCallbacks {
+    /** User submitted the form (the SUBMIT action — wallet prompt is about to fire). */
+    onWithdrawalConfirmed?: () => void;
+    /** Quote entity reached `ready` with the formatted payload. */
+    onQuoteResolved?: (quote: WithdrawalQuotePayload) => void;
+    /** Quote entity reached `error`. */
+    onQuoteFailed?: (failure: {
+      reason: string;
+      code?: string;
+    }) => void;
+    /** Wagmi broadcast completed and the orchestrator transitioned into `inProgress`. */
+    onWithdrawalSubmitted?: (event: {
+      input: SubmitWithdrawalInput;
+      tx: TxRef;
+    }) => void;
+    /** User declined the wallet signature prompt; orchestrator transitioned into `error`. */
+    onSignatureDeclined?: () => void;
+    /** Submission failed for a non-rejection reason (network, bad input, etc). */
+    onSubmissionFailed?: (failure: FailureInfo) => void;
+    /** The driver's `settlement` entity emitted a progressive pending update. */
+    onProcessingProgress?: (update: WithdrawalSettlementPendingPayload) => void;
+    /** Terminal success — settlement entity reached `ready{kind: "succeeded"}`. */
+    onSucceeded?: (result: WithdrawalSettlementSuccessPayload) => void;
+    /**
+     * Terminal failure — either a settlement-driven failure (driver-emitted classification) or
+     * an FSM-derived failure (submission rejection escalated to the global error arm).
+     */
+    onFailed?: (failure: WithdrawalSettlementFailurePayload | FailureInfo) => void;
+  }
+}
+//#endregion
+export { WithdrawDialog };

package/dist/flows/withdraw/dialog/WithdrawDialog.js

@@ -0,0 +1 @@
+"use client";import{useDialogLifecycle as e}from"../../../shared/orchestrator/useDialogLifecycle.js";import"../../../shared/orchestrator/index.js";import{useWithdrawSnapshot as t}from"../driver/context.js";import{useWithdrawEffectiveState as n,useWithdrawState as r}from"../orchestrator/controller.js";import{useWithdraw as i}from"../orchestrator/useWithdraw.js";import"../orchestrator/index.js";import{Dialog as a}from"../../../shared/ui/Dialog/Dialog.js";import"../../../shared/ui/Dialog/index.js";import{StepTransition as o}from"../../../shared/dialog/StepTransition.js";import{GatewayKitBoundary as s}from"../../../shared/error-handling/components/GatewayKitBoundary.js";import"../../../shared/error-handling/index.js";import{WithdrawError as c}from"../widgets/withdraw-error/WithdrawError.js";import{WithdrawDialogEventsProvider as l}from"./WithdrawDialogEventsContext.js";import{WithdrawForm as u}from"../widgets/withdraw-form/WithdrawForm.js";import{WithdrawInProgress as d}from"../widgets/withdraw-in-progress/WithdrawInProgress.js";import{WithdrawSuccess as f}from"../widgets/withdraw-success/WithdrawSuccess.js";import"../../../_internal/withdraw/widgets/index.js";import{useRef as p}from"react";import{jsx as m,jsxs as h}from"react/jsx-runtime";function g({container:e,onError:p,onOpened:g,onClosed:v,onStepChanged:y,events:b}={}){let x=r(),S=n(),{close:C}=i(),w=t(),T=x.name!==`closed`;_(x,w.settlement,w.quote,{onOpened:g,onClosed:v,onStepChanged:y,events:b});let E=S.name===`submitting`?`form`:S.name;return m(a,{open:T,onOpenChange:e=>e?void 0:C(),children:m(a.Content,{container:e,children:m(s,{onError:p,onReset:C,children:m(l,{events:b??{},children:h(o,{stateKey:E,children:[S.name===`form`||S.name===`submitting`?m(u,{}):null,S.name===`inProgress`?m(d,{}):null,S.name===`success`?m(f,{}):null,S.name===`error`?m(c,{}):null]})})})})})}function _(t,n,r,i){let a=p(i);a.current=i,e({state:t,settlement:n,quote:r,fireFsm:(e,t)=>v(e,t,a.current),fireSettlement:(e,t)=>y(t,a.current),fireQuote:(e,t)=>{if(t.status===e)return;let n=a.current.events;t.status===`ready`&&n?.onQuoteResolved?.(t.payload),t.status===`error`&&n?.onQuoteFailed?.({reason:t.error.message||`Quote failed.`,...t.error.name?{code:t.error.name}:{}})}})}function v(e,t,n){let{onOpened:r,onClosed:i,onStepChanged:a,events:o}=n,s=e.name===`form`&&!!e.ctx?.notice;if(t.name===`form`&&t.ctx?.notice&&!s&&o?.onSignatureDeclined?.(),e.name!==t.name&&(e.name===`closed`&&t.name!==`closed`&&r?.(),e.name!==`closed`&&t.name===`closed`&&i?.(e.name),a?.({from:e.name,to:t.name}),e.name===`form`&&t.name===`submitting`&&o?.onWithdrawalConfirmed?.(),e.name===`submitting`&&t.name===`inProgress`&&o?.onWithdrawalSubmitted?.({input:t.ctx.input,tx:t.ctx.tx}),t.name===`error`)){let e=t.ctx.failure;e!==void 0&&t.ctx.tx===void 0&&e&&(o?.onSubmissionFailed?.(e),o?.onFailed?.(e))}}function y(e,t){if(e.status!==`ready`&&e.status!==`stale`)return;let n=e.payload,r=t.events;if(r){if(n.kind===`pending`){r.onProcessingProgress?.(n);return}if(n.kind===`succeeded`){r.onSucceeded?.(n);return}n.kind===`failed`&&r.onFailed?.(n)}}export{g as WithdrawDialog};

package/dist/flows/withdraw/dialog/WithdrawDialogEventsContext.d.ts

@@ -0,0 +1,36 @@
+import { ReceiveChainPayload, ReceiveTokenOptionPayload } from "../driver/payloads.js";
+import { RequestWithdrawalQuoteInput } from "../driver/types.js";
+import { ReactNode } from "react";
+//#region src/flows/withdraw/dialog/WithdrawDialogEventsContext.d.ts
+/**
+ * Form-level event payload — the parsed amount the user typed, alongside the raw input string.
+ * `numeric` is `null` when the input is empty or unparseable; the host can treat that as "user
+ * cleared the amount" rather than re-parse the raw string.
+ */
+interface AmountChangedPayload {
+  raw: string;
+  numeric: number | null;
+}
+/**
+ * Form-level callbacks reading off `WithdrawForm`'s local state. Optional — hosts wiring
+ * `<WithdrawDialog>` configure them via the `events` prop, hosts using `<WithdrawForm>` directly
+ * pass them via the form's `events` prop.
+ */
+interface WithdrawFormEventCallbacks {
+  /** Fires on every recipient-input change (no debounce). */
+  onRecipientChanged?: (value: string) => void;
+  /** Fires on every amount-input change with both the raw string and the parsed numeric value. */
+  onAmountChanged?: (payload: AmountChangedPayload) => void;
+  /** Fires when the user picks a different receive token in the form's receive-token dropdown. */
+  onReceiveTokenChanged?: (token: ReceiveTokenOptionPayload) => void;
+  /** Fires when the user picks a different receive chain in the form's receive-chain dropdown. */
+  onReceiveChainChanged?: (chain: ReceiveChainPayload) => void;
+  /**
+   * Fires when the form fires a fresh `requestQuote` (after the 400ms debounce). The input
+   * carries everything the driver received so the host can mirror the request shape into
+   * analytics or pre-warm host-side caches.
+   */
+  onQuoteRequested?: (input: RequestWithdrawalQuoteInput) => void;
+}
+//#endregion
+export { WithdrawFormEventCallbacks };

package/dist/flows/withdraw/dialog/WithdrawDialogEventsContext.js

@@ -0,0 +1 @@
+"use client";import{createContext as e,use as t}from"react";import{jsx as n}from"react/jsx-runtime";const r=e({});r.displayName=`WithdrawDialogEventsContext`;function i({events:e,children:t}){return n(r,{value:e,children:t})}function a(){return t(r)}export{i as WithdrawDialogEventsProvider,a as useWithdrawDialogEvents};

package/dist/flows/withdraw/driver/context.d.ts

@@ -0,0 +1,24 @@
+import { WithdrawDriver, WithdrawSnapshot } from "./types.js";
+import { ReactNode } from "react";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/flows/withdraw/driver/context.d.ts
+declare function WithdrawDriverProvider({
+  driver,
+  children
+}: {
+  driver: WithdrawDriver;
+  children: ReactNode;
+}): _$react_jsx_runtime0.JSX.Element;
+/**
+ * Read the current withdraw driver snapshot. Throws when called outside `<KitProvider withdraw={…} />`.
+ *
+ * Wraps `subscribe` / `getSnapshot` in lambdas so the call resolves through the driver instance.
+ * Class-based BYO drivers would otherwise lose their `this` binding when React invokes the
+ * methods detached from the instance.
+ */
+declare function useWithdrawSnapshot(): WithdrawSnapshot;
+/** Internal — read the raw driver instance (skips React's snapshot subscription). */
+declare function useWithdrawDriverInstance(): WithdrawDriver;
+//#endregion
+export { WithdrawDriverProvider, useWithdrawDriverInstance, useWithdrawSnapshot };

package/dist/flows/withdraw/driver/context.js

@@ -0,0 +1 @@
+"use client";import{createContext as e,use as t,useSyncExternalStore as n}from"react";import{jsx as r}from"react/jsx-runtime";const i=e(null);i.displayName=`WithdrawDriverContext`;function a({driver:e,children:t}){return r(i,{value:e,children:t})}function o(){let e=t(i);if(!e)throw Error(`useWithdrawSnapshot must be used inside <KitProvider withdraw={…} />.`);return n(t=>e.subscribe(t),()=>e.getSnapshot(),()=>e.getSnapshot())}function s(){let e=t(i);if(!e)throw Error(`useWithdrawDriverInstance must be used inside <KitProvider withdraw={…} />.`);return e}export{a as WithdrawDriverProvider,s as useWithdrawDriverInstance,o as useWithdrawSnapshot};

package/dist/flows/withdraw/driver/dto.d.ts

@@ -0,0 +1,41 @@
+import { GatewayPollResponse, GatewaySettlementDto, OnchainBalanceResponse, QuoteResponse, SupportedAssetDto, SupportedAssetsResponse } from "@stridge/sdk";
+
+//#region src/flows/withdraw/driver/dto.d.ts
+/**
+ * Per-token row from the gateway's `balance/onchain` proxy. The withdraw driver filters this list
+ * down to the configured brand-currency tuple before formatting.
+ */
+type WithdrawableBalanceDto = OnchainBalanceResponse["chains"][number]["tokens"][number];
+/**
+ * Full `balance/onchain` response. The driver filters `chains[].tokens[]` to the brand-currency
+ * `(networkId, assetSymbol)` tuple at format time.
+ */
+type WithdrawableBalancesResponse = OnchainBalanceResponse;
+/** Per-call `uda/quote` response. Drives the V2 form's "You will receive" + breakdown rows. */
+type WithdrawalQuoteDto = QuoteResponse;
+/** Alias of {@link WithdrawalQuoteDto} surfaced as the response slot for parity with deposit. */
+type WithdrawalQuoteResponse = QuoteResponse;
+/**
+ * Single settlement record from `gateway/{owner}`. The withdraw driver matches by source-chain
+ * `from.tx_id` (the wagmi-broadcast hash) and routes the matched settlement through
+ * `settlementToWithdrawalPayload` to build the payload union.
+ */
+type WithdrawalSettlementDto = GatewaySettlementDto;
+/**
+ * Full `gateway/{owner}` poll response. Carries `destination` plus `settlements[]`. Used as the
+ * `response` slot on the settlement entity envelope so headless integrators can correlate against
+ * the UDA-level destination metadata.
+ */
+type WithdrawalSettlementResponse = GatewayPollResponse;
+/**
+ * Per-network entry from `Uda.supportedAssets()`. Surfaced as the `raw` slot on the
+ * `receiveOptions` entity so headless integrators can navigate the catalog without re-fetching.
+ */
+type ReceiveOptionDto = SupportedAssetDto;
+/**
+ * Full `Uda.supportedAssets()` response. Drives the receive chain + receive token dropdowns on
+ * the form.
+ */
+type ReceiveOptionsResponse = SupportedAssetsResponse;
+//#endregion
+export { ReceiveOptionDto, ReceiveOptionsResponse, WithdrawableBalanceDto, WithdrawableBalancesResponse, WithdrawalQuoteDto, WithdrawalQuoteResponse, WithdrawalSettlementDto, WithdrawalSettlementResponse };

package/dist/flows/withdraw/driver/payloads.d.ts

@@ -0,0 +1,206 @@
+import { SettlementFailureKind } from "../../../shared/driver/types.js";
+import { FormattedField } from "../../../shared/format/types.js";
+//#region src/flows/withdraw/driver/payloads.d.ts
+/**
+ * Per-asset balance available to withdraw — the brand-managed source the cash-out flow draws
+ * from. Mirrors the shape of {@link import("#/flows/deposit/driver").BalanceItemPayload} on the
+ * deposit side, but the underlying store is the brand's settlement account rather than the
+ * connected wallet.
+ */
+interface WithdrawableBalanceItemPayload {
+  /** Stridge network id (string-encoded). */
+  networkId?: string;
+  /** Human-readable network name (e.g. `"Polygon"`). */
+  networkName: string;
+  /** EIP-155 chain id when applicable. */
+  eip155Id?: string;
+  /** Resolved chain icon URL. */
+  chainLogoUrl?: string;
+  /** Token symbol as displayed (e.g. `"USDC"`). */
+  symbol: string;
+  /** On-chain decimal precision. */
+  decimals: number;
+  /** ERC-20 contract address. Empty string for native assets. */
+  address: string;
+  /** Resolved token icon URL. */
+  assetLogoUrl?: string;
+  /** True for the chain's native gas token. */
+  isNative: boolean;
+  /** Withdrawable balance in display units (post-decimals). */
+  amount: FormattedField<number>;
+  /** USD value of `amount` at the most recent price snapshot. */
+  amountUsd?: FormattedField<number>;
+}
+/**
+ * Receive-side asset descriptor surfaced on the quote / settlement payloads — the token + chain
+ * the withdraw is settling into. Carries the token glyph metadata the form's "Receive token" /
+ * "Receive chain" pickers render.
+ */
+interface WithdrawalReceiveAssetPayload {
+  /** Token symbol displayed on the receive pill. */
+  symbol: string;
+  /** On-chain decimal precision. */
+  decimals: number;
+  /** ERC-20 contract address on the receive chain. Empty for native. */
+  address: string;
+  /** True for the chain's native gas token. */
+  isNative: boolean;
+  /** Resolved token icon URL. */
+  assetLogoUrl?: string;
+  /** Stridge network id for the receive chain. */
+  networkId?: string;
+  /** Human-readable network name (e.g. `"Polygon"`). */
+  networkName: string;
+  /** EIP-155 chain id of the receive chain. */
+  eip155Id?: string;
+  /** Resolved chain icon URL. */
+  chainLogoUrl?: string;
+}
+/**
+ * Quote breakdown rows surfaced on the V2 form's expandable breakdown card. Mirrors the deposit
+ * flow's breakdown shape so both flows render the same items (selected route, network cost,
+ * price impact). Each field is independently optional so the row hides when the gateway didn't
+ * surface that detail.
+ */
+interface WithdrawalQuoteBreakdownPayload {
+  /**
+   * Routing context selected by the backend (provider + scenario). The widget renders
+   * `label` directly. Identical shape to deposit's `selectedRoute` so both flows surface the
+   * same chrome.
+   */
+  selectedRoute?: {
+    provider: string;
+    scenario: string;
+    label: string;
+  };
+  /** Estimated network cost in USD. */
+  networkCost?: FormattedField<number>;
+  /** Price impact in percent units (`0.21` means `0.21%`). Only set on same-symbol routes. */
+  priceImpact?: FormattedField<number>;
+}
+/**
+ * Active withdrawal quote — the formatted result of a `requestWithdrawalQuote` round-trip. Drives
+ * the form's "You will receive" summary row and the breakdown card's three metric rows.
+ */
+interface WithdrawalQuotePayload {
+  /** Receive-side asset + chain chrome. */
+  receiveAsset: WithdrawalReceiveAssetPayload;
+  /** Receive amount in display units (after fees / route conversion). */
+  receiveAmount: FormattedField<number>;
+  /** Receive amount in USD at the most recent price snapshot. */
+  receiveAmountUsd?: FormattedField<number>;
+  /** Optional breakdown rows (network cost / price impact / max slippage). */
+  breakdown?: WithdrawalQuoteBreakdownPayload;
+  /**
+   * Total seconds the quote window starts at — drives any quote-staleness countdown a future
+   * variant might surface. Defaults to `30` when the gateway does not surface a per-quote
+   * freshness window.
+   */
+  quoteTotalSeconds: number;
+  /** Unix-ms timestamp at which the quote expires and the entity transitions to `stale`. */
+  expiresAt: number;
+}
+/**
+ * Pending variant of the settlement entity — the broadcast has been observed but the settlement
+ * has not yet reached a terminal verdict. Drives the V2-5 "Withdrawal in progress" screen.
+ */
+interface WithdrawalSettlementPendingPayload {
+  kind: "pending";
+  receiveAsset: WithdrawalReceiveAssetPayload;
+  receiveAmount: FormattedField<number>;
+  /** Recipient address — the destination the user supplied on the form. */
+  recipient: FormattedField<string>;
+  /** Unix-ms timestamp when the withdrawal was submitted. */
+  submittedAt: FormattedField<number>;
+  /** Source-chain broadcast tx hash. */
+  txHash?: FormattedField<string>;
+  /** Block-explorer URL for `txHash.value`. */
+  txExplorerUrl?: string;
+}
+/**
+ * Succeeded variant — the settlement reached terminal success. Drives the V2-6 "Withdrawal
+ * successful" screen.
+ */
+interface WithdrawalSettlementSuccessPayload {
+  kind: "succeeded";
+  receiveAsset: WithdrawalReceiveAssetPayload;
+  receiveAmount: FormattedField<number>;
+  recipient: FormattedField<string>;
+  submittedAt: FormattedField<number>;
+  /** Unix-ms when the settlement reached `completed`. */
+  filledAt: FormattedField<number>;
+  /** Total time from submit to terminal verdict. */
+  totalTime: FormattedField<number>;
+  /** Source-chain broadcast tx hash. */
+  txHash: FormattedField<string>;
+  txExplorerUrl?: string;
+  /** Destination-chain settlement tx — populated once the gateway submits the receive leg. */
+  completionTx?: {
+    hash: FormattedField<string>;
+    explorerUrl?: string;
+  };
+}
+/**
+ * Failed variant — the settlement reached a terminal failure. The V2 error path reuses the
+ * shared `<ErrorState>` compound; the V2-native error design is deferred to a follow-up. Reuses
+ * deposit's {@link SettlementFailureKind} taxonomy so the localized headline / reason mapping
+ * can stay shared across flows.
+ */
+interface WithdrawalSettlementFailurePayload {
+  kind: "failed";
+  failureKind: SettlementFailureKind;
+  receiveAsset: WithdrawalReceiveAssetPayload;
+  receiveAmount: FormattedField<number>;
+  recipient: FormattedField<string>;
+  submittedAt: FormattedField<number>;
+  /** Unix-ms when the settlement reached `failed`. */
+  failedAt: FormattedField<number>;
+  txHash?: FormattedField<string>;
+  txExplorerUrl?: string;
+}
+/**
+ * Discriminated union for the withdraw settlement entity. The same envelope drives every state
+ * screen that reads settlement data — the discriminator on `kind` selects the variant.
+ */
+type WithdrawalSettlementPayload = WithdrawalSettlementPendingPayload | WithdrawalSettlementSuccessPayload | WithdrawalSettlementFailurePayload;
+/**
+ * One token entry in a receive-chain's catalog. Surfaced to the form's "Receive token" dropdown
+ * after the user picks a "Receive chain". Includes the chain's native currency (`isNative: true`)
+ * alongside the configured ERC-20s, mirroring the transfer-crypto picker's two-tier shape.
+ */
+interface ReceiveTokenOptionPayload {
+  /** Token symbol (e.g. `"USDC"`, `"ETH"`). */
+  symbol: string;
+  /** Display name (e.g. `"USD Coin"`). */
+  name: string;
+  /** ERC-20 contract address. Empty string for native gas tokens. */
+  address: string;
+  /** On-chain decimal precision. */
+  decimals: number;
+  /** True when the row is the chain's native gas token. */
+  isNative: boolean;
+  /** Resolved token icon URL. */
+  assetLogoUrl?: string;
+}
+/**
+ * One receive chain available for routing — the per-network catalog the form's "Receive chain"
+ * dropdown renders. Each chain carries its native gas token plus configured ERC-20s.
+ */
+interface ReceiveChainPayload {
+  /** Stridge network id (string-encoded, e.g. `"60"`, `"9006"`). */
+  networkId: string;
+  /** Human-readable network name (e.g. `"Polygon"`). */
+  networkName: string;
+  /** EIP-155 chain id (numeric). */
+  eip155Id: number;
+  /** Resolved chain icon URL — derived from the chain's native_currency.logo. */
+  chainLogoUrl?: string;
+  /**
+   * Selectable token rows for this chain. Always non-empty: starts with the chain's native gas
+   * token and is followed by every configured ERC-20 the gateway routes to. The form's
+   * "Receive token" dropdown narrows to whichever entry the active receive chain supplies.
+   */
+  tokens: ReadonlyArray<ReceiveTokenOptionPayload>;
+}
+//#endregion
+export { ReceiveChainPayload, ReceiveTokenOptionPayload, WithdrawableBalanceItemPayload, WithdrawalQuoteBreakdownPayload, WithdrawalQuotePayload, WithdrawalReceiveAssetPayload, WithdrawalSettlementFailurePayload, WithdrawalSettlementPayload, WithdrawalSettlementPendingPayload, WithdrawalSettlementSuccessPayload };

package/dist/flows/withdraw/driver/transformers/balanceToWithdrawableBalancesPayload.js

@@ -0,0 +1 @@
+import{parseDecimalSafe as e}from"../../../shared/transformers/parseSmallestUnit.js";import{formatTokenAmount as t}from"../../../../shared/format/formatTokenAmount.js";import{formatUsd as n}from"../../../../shared/format/formatUsd.js";function r(r,i){let a=i.assetSymbol.toUpperCase(),o=i.fallbackMeta?.address?.toLowerCase(),s=r.chains.find(e=>e.stridge_network_id===i.networkId),c=s?s.tokens.filter(e=>!e.is_spam&&e.symbol.toUpperCase()===a):[],l=o?c.find(e=>e.token_address.toLowerCase()===o)??c[0]:c[0];if(s&&l){let r=e(l.amount),a=e(l.amount_usd);return[{networkId:s.stridge_network_id,networkName:s.label,eip155Id:String(s.eip155_id),...i.fallbackMeta?.chainLogoUrl?{chainLogoUrl:i.fallbackMeta.chainLogoUrl}:{},symbol:l.symbol,decimals:l.decimals,address:l.token_address,...l.logo?{assetLogoUrl:l.logo}:i.fallbackMeta?.assetLogoUrl?{assetLogoUrl:i.fallbackMeta.assetLogoUrl}:{},isNative:l.is_native,amount:{value:r,formatted:t(r,i.i18n,{compact:!0})},...a>0?{amountUsd:{value:a,formatted:n(a,i.i18n)}}:{}}]}return i.fallbackMeta?[{networkId:i.networkId,networkName:i.fallbackMeta.networkName??i.networkId,...i.fallbackMeta.eip155Id?{eip155Id:i.fallbackMeta.eip155Id}:{},...i.fallbackMeta.chainLogoUrl?{chainLogoUrl:i.fallbackMeta.chainLogoUrl}:{},symbol:i.assetSymbol,decimals:i.fallbackMeta.decimals,address:i.fallbackMeta.address,...i.fallbackMeta.assetLogoUrl?{assetLogoUrl:i.fallbackMeta.assetLogoUrl}:{},isNative:i.fallbackMeta.isNative,amount:{value:0,formatted:t(0,i.i18n,{compact:!0})},amountUsd:{value:0,formatted:n(0,i.i18n)}}]:[]}export{r as balanceToWithdrawableBalancesPayload};

package/dist/flows/withdraw/driver/transformers/quoteToWithdrawalPayload.js

@@ -0,0 +1 @@
+import{computeQuoteAttrs as e,formatRouteLabel as t}from"../../../shared/transformers/computeQuoteAttrs.js";import{formatNetworkName as n}from"../../../../shared/format/formatNetworkName.js";import{formatPercent as r}from"../../../../shared/format/formatPercent.js";import{formatTokenAmount as i}from"../../../../shared/format/formatTokenAmount.js";import{formatUsd as a}from"../../../../shared/format/formatUsd.js";function o(o,s){let c=e(o,{sourceAmount:s.sourceAmount,sendDecimals:s.sendDecimals,sendSymbol:s.sendSymbol,receiveDecimals:s.receiveSide.decimals,receiveSymbol:s.receiveSide.symbol,...s.sendPriceUsd===void 0?{}:{sendPriceUsd:s.sendPriceUsd},...s.receivePriceUsd===void 0?{}:{receivePriceUsd:s.receivePriceUsd},now:s.now}),l={};return o.route.provider&&(l.selectedRoute={provider:o.route.provider,scenario:o.route.scenario??``,label:t(o.route.provider,o.route.scenario)}),c.networkCostUsd!==void 0&&(l.networkCost={value:c.networkCostUsd,formatted:a(c.networkCostUsd,s.i18n)}),c.priceImpactPercent!==void 0&&(l.priceImpact={value:c.priceImpactPercent,formatted:r(c.priceImpactPercent,s.i18n)}),{receiveAsset:{symbol:s.receiveSide.symbol,decimals:s.receiveSide.decimals,address:s.receiveSide.address,isNative:s.receiveSide.isNative,...s.receiveSide.assetLogoUrl?{assetLogoUrl:s.receiveSide.assetLogoUrl}:{},...s.receiveSide.networkId?{networkId:s.receiveSide.networkId}:{},networkName:n(s.receiveSide.networkName),eip155Id:String(s.receiveSide.chainId),...s.receiveSide.chainLogoUrl?{chainLogoUrl:s.receiveSide.chainLogoUrl}:{}},receiveAmount:{value:c.receiveAmount,formatted:i(c.receiveAmount,s.i18n,{maxDecimals:s.receiveSide.decimals})},...c.receiveAmountUsd===void 0?{}:{receiveAmountUsd:{value:c.receiveAmountUsd,formatted:a(c.receiveAmountUsd,s.i18n)}},quoteTotalSeconds:30,expiresAt:Math.min(c.expiresAt,s.now+30*1e3),...Object.keys(l).length>0?{breakdown:l}:{}}}export{o as quoteToWithdrawalPayload};

package/dist/flows/withdraw/driver/transformers/settlementToWithdrawalPayload.js

@@ -0,0 +1 @@
+import{classifyFailureKind as e,classifySettlementStatus as t}from"../../../shared/transformers/classifySettlementStatus.js";import{parseDecimalSafe as n,parseSmallestUnit as r}from"../../../shared/transformers/parseSmallestUnit.js";import{parseIsoMs as i}from"../../../shared/transformers/parseIsoMs.js";import{formatDurationCompact as a}from"../../../../shared/format/formatDurationCompact.js";import{formatTimestamp as o}from"../../../../shared/format/formatTimestamp.js";import{formatTokenAmount as s}from"../../../../shared/format/formatTokenAmount.js";import{shortenAddress as c}from"../../../../shared/format/shortenAddress.js";function l(e,n,r){let i=t(e.status);return i===`completed`?d(e,n,r):i===`failed`?f(e,n,r):u(e,n,r)}function u(e,t,n){let r=e.from,a=e.to,l=i(r?.confirmed_at)??i(e.created_at)??Date.now(),u=p(t,n),d=m(a,t.destination.asset_decimals)||m(r,r?.asset_decimals??t.destination.asset_decimals),f=t.destination.address,g=r?.tx_id,_=r?.eip155_id===void 0?void 0:Number(r.eip155_id);return{kind:`pending`,receiveAsset:u,receiveAmount:{value:d,formatted:s(d,n.i18n,{maxDecimals:t.destination.asset_decimals})},recipient:{value:f,formatted:c(f)},submittedAt:{value:l,formatted:o(l,n.i18n)},...g?{txHash:{value:g,formatted:c(g)},...h(n,_,g)?{txExplorerUrl:h(n,_,g)}:{}}:{}}}function d(e,t,n){let r=e.from,l=e.to,u=i(r?.confirmed_at)??i(e.created_at)??Date.now(),d=i(l?.settled_at)??i(e.updated_at)??Date.now(),f=Math.max(0,d-u),_=Math.round(f/1e3),v=p(t,n),y=m(l,t.destination.asset_decimals),b=t.destination.address,x=r?.tx_id??``,S=r?.eip155_id===void 0?void 0:Number(r.eip155_id),C=l?.tx_id,w=h(n,g(l?.eip155_id)??g(t.destination.eip155_id),C);return{kind:`succeeded`,receiveAsset:v,receiveAmount:{value:y,formatted:s(y,n.i18n,{maxDecimals:t.destination.asset_decimals})},recipient:{value:b,formatted:c(b)},submittedAt:{value:u,formatted:o(u,n.i18n)},filledAt:{value:d,formatted:o(d,n.i18n)},totalTime:{value:_,formatted:a(f,n.i18n)},txHash:{value:x,formatted:x?c(x):``},...h(n,S,x)?{txExplorerUrl:h(n,S,x)}:{},...C?{completionTx:{hash:{value:C,formatted:c(C)},...w?{explorerUrl:w}:{}}}:{}}}function f(t,n,r){let a=t.from,l=i(a?.confirmed_at)??i(t.created_at)??Date.now(),u=i(t.updated_at)??Date.now(),d=p(n,r),f=n.destination.address,m=a?.tx_id,g=a?.eip155_id===void 0?void 0:Number(a.eip155_id);return{kind:`failed`,failureKind:e(t.error),receiveAsset:d,receiveAmount:{value:0,formatted:s(0,r.i18n)},recipient:{value:f,formatted:c(f)},submittedAt:{value:l,formatted:o(l,r.i18n)},failedAt:{value:u,formatted:o(u,r.i18n)},...m?{txHash:{value:m,formatted:c(m)},...h(r,g,m)?{txExplorerUrl:h(r,g,m)}:{}}:{}}}function p(e,t){let n=t.receiveAssetEnrichment,r=Number(e.destination.eip155_id);return{symbol:e.destination.asset_symbol,decimals:e.destination.asset_decimals,address:e.destination.asset_address,isNative:!e.destination.asset_address,...n?.assetLogoUrl?{assetLogoUrl:n.assetLogoUrl}:{},networkId:e.destination.network_id,networkName:n?.networkName??e.destination.network_name,...Number.isFinite(r)?{eip155Id:e.destination.eip155_id}:{},...n?.chainLogoUrl?{chainLogoUrl:n.chainLogoUrl}:{}}}function m(e,t){if(!e)return 0;if(e.amount){let t=n(e.amount);if(t>0)return t}return e.raw_amount?r(e.raw_amount,t):0}function h(e,t,n){if(!n||t===void 0)return;let r=e.explorers?.[t];if(r)return`${r.replace(/\/+$/,``)}/tx/${n}`}function g(e){if(e==null||e===``)return;let t=Number(e);return Number.isFinite(t)?t:void 0}export{l as settlementToWithdrawalPayload};

package/dist/flows/withdraw/driver/transformers/supportedAssetsToReceiveOptionsPayload.js

@@ -0,0 +1 @@
+import{formatNetworkName as e}from"../../../../shared/format/formatNetworkName.js";function t(t,n={}){let r=n.excludedChainIds,i=[];for(let n of t.assets){if(r?.has(n.eip155_id))continue;let t=n.native_currency,a=new Set,o=(e,t)=>`${e.toUpperCase()}@${t.toLowerCase()}`,s=[];if(t?.symbol){let e={symbol:t.symbol,name:t.name??t.symbol,address:``,decimals:typeof t.decimals==`number`?t.decimals:18,isNative:!0,...t.logo?{assetLogoUrl:t.logo}:{}};s.push(e),a.add(o(e.symbol,e.address))}let c=t?.symbol?.toUpperCase();for(let e of n.assets){if(!e.symbol||!e.address||c&&e.symbol.toUpperCase()===c)continue;let t=o(e.symbol,e.address);a.has(t)||(a.add(t),s.push({symbol:e.symbol,name:e.name??e.symbol,address:e.address,decimals:e.decimals,isNative:!1,...e.logo?{assetLogoUrl:e.logo}:{}}))}s.length!==0&&i.push({networkId:n.network_id,networkName:e(n.network_name),eip155Id:n.eip155_id,...t?.logo?{chainLogoUrl:t.logo}:{},tokens:s})}return i.sort((e,t)=>e.eip155Id-t.eip155Id),i}export{t as supportedAssetsToReceiveOptionsPayload};

package/dist/flows/withdraw/driver/types.d.ts

@@ -0,0 +1,133 @@
+import { Entity, SettlementFailureKind, TxRef } from "../../../shared/driver/types.js";
+import { ReceiveOptionDto, ReceiveOptionsResponse, WithdrawableBalanceDto, WithdrawableBalancesResponse, WithdrawalQuoteDto, WithdrawalQuoteResponse, WithdrawalSettlementDto, WithdrawalSettlementResponse } from "./dto.js";
+import { ReceiveChainPayload, ReceiveTokenOptionPayload, WithdrawableBalanceItemPayload, WithdrawalQuoteBreakdownPayload, WithdrawalQuotePayload, WithdrawalReceiveAssetPayload, WithdrawalSettlementFailurePayload, WithdrawalSettlementPayload, WithdrawalSettlementPendingPayload, WithdrawalSettlementSuccessPayload } from "./payloads.js";
+
+//#region src/flows/withdraw/driver/types.d.ts
+/**
+ * Snapshot of every reactive entity the withdraw driver exposes. Returned by
+ * {@link WithdrawDriver.getSnapshot} and consumed by `useSyncExternalStore`. The kit's
+ * `useWithdrawSnapshot()` hook returns this shape.
+ *
+ * Each field is an {@link Entity} envelope — components switch on `status` and read `payload` on
+ * the `ready` / `stale` variants.
+ */
+interface WithdrawSnapshot {
+  /**
+   * Withdrawable balance for the brand-currency tuple the driver was configured with. The
+   * V2 form ships single-source-row UX, so this list always has zero or one entry today; the
+   * shape stays array-typed so future variants can extend without a contract break.
+   *
+   * Backed by `sdk.balance.onchain(userAddress)` filtered to the configured `(networkId,
+   * assetSymbol)`. An empty wallet position surfaces as a single row with `amount.value === 0`.
+   */
+  withdrawableBalances: Entity<ReadonlyArray<WithdrawableBalanceItemPayload>, WithdrawableBalancesResponse, WithdrawableBalancesResponse>;
+  /**
+   * Per-chain catalog of routable receive destinations. Drives the form's "Receive chain" /
+   * "Receive token" pickers. Derived from `Uda.supportedAssets()`.
+   */
+  receiveOptions: Entity<ReadonlyArray<ReceiveChainPayload>, ReadonlyArray<ReceiveOptionDto>, ReceiveOptionsResponse>;
+  /**
+   * Active withdrawal quote. Drives the V2 form's "You will receive" summary row and the
+   * breakdown card's three metric rows. Transitions to `stale` on expiry.
+   */
+  quote: Entity<WithdrawalQuotePayload, WithdrawalQuoteDto, WithdrawalQuoteResponse>;
+  /**
+   * Most-recent settlement observed for the active withdraw. The discriminated `kind` on the
+   * payload (`pending` / `succeeded` / `failed`) drives whether the in-progress / success /
+   * error state screen renders.
+   */
+  settlement: Entity<WithdrawalSettlementPayload, WithdrawalSettlementDto, WithdrawalSettlementResponse>;
+}
+/**
+ * Input to {@link WithdrawDriver.requestQuote}. The form widget builds this from current field
+ * values and fires it as the user types (debounced).
+ */
+interface RequestWithdrawalQuoteInput {
+  /** Source-side asset symbol the withdraw is drawing from (the brand-managed balance row). */
+  sourceAssetSymbol: string;
+  /** Source-side chain id (EIP-155). */
+  sourceChainId: number;
+  /** Send amount in display units. */
+  amount: number;
+  /** Receive-side token symbol the user picked on the form. */
+  receiveTokenSymbol: string;
+  /** Receive-side chain id (EIP-155). */
+  receiveChainId: number;
+  /** Recipient address the user typed (or pasted) into the form. */
+  recipientAddress: string;
+}
+/**
+ * Input to {@link WithdrawDriver.submitWithdrawal}. Identical to {@link RequestWithdrawalQuoteInput}
+ * — the live driver re-uses the most recent quote for submit, so the same identifying fields
+ * scope both calls.
+ */
+type SubmitWithdrawalInput = RequestWithdrawalQuoteInput;
+/**
+ * Input to {@link WithdrawDriver.watchSettlement}. Carries the broadcast tx ref so the watcher
+ * can scope its poll to the in-flight withdraw.
+ */
+interface WatchWithdrawalSettlementInput {
+  tx: TxRef;
+}
+/**
+ * Input to {@link WithdrawDriver.watchWithdrawableBalances}. Optional listener — the form's
+ * source-side display reflects whatever the driver surfaces (no parameters needed today; the
+ * shape is reserved for future filters).
+ */
+type WatchWithdrawableBalancesInput = Record<string, never>;
+/**
+ * Withdraw driver contract. Mirrors {@link import("#/flows/deposit/driver").DepositDriver}'s
+ * shape (host-supplied source of reactive data + imperative actions) but scoped to the withdraw
+ * flow. The driver also implements the `useSyncExternalStore` contract (`subscribe` +
+ * `getSnapshot`) so `<KitProvider />` + `useWithdrawSnapshot()` get standard React 18+
+ * external-store semantics.
+ *
+ * Two implementations ship from the kit:
+ *
+ * - `@stridge/kit/drivers/stridge-mock` — deterministic mock backed by synthetic fixtures. Used
+ *   by demos, Storybook, tests, and any `<KitProvider />` mount that doesn't need a live gateway.
+ * - `@stridge/kit/drivers/stridge` — the live Stridge gateway driver
+ *   (`createStridgeWithdrawDriver`).
+ *
+ * @example
+ *
+ * ```tsx
+ * import { createStridgeMockWithdrawDriver } from "@stridge/kit/drivers/stridge-mock";
+ * import { KitProvider } from "@stridge/kit";
+ *
+ * const { driver } = createStridgeMockWithdrawDriver();
+ *
+ * <KitProvider withdraw={driver}>
+ *     <YourApp />
+ * </KitProvider>;
+ * ```
+ */
+interface WithdrawDriver {
+  /** Read the current snapshot of every reactive entity (used by `useSyncExternalStore`). */
+  getSnapshot(): WithdrawSnapshot;
+  /** Subscribe to entity transitions outside React (analytics, headless integrations). */
+  subscribe(listener: () => void): () => void;
+  /**
+   * Fetches a fresh quote for `input` and updates the `quote` entity through its lifecycle
+   * (`idle | loading → ready | error`). The `signal` cancels in-flight work.
+   */
+  requestQuote(input: RequestWithdrawalQuoteInput, signal: AbortSignal): Promise<void>;
+  /**
+   * Submits the confirmed withdrawal. Resolves with the broadcast tx ref. The settlement
+   * watcher takes over from there to populate the `settlement` entity.
+   */
+  submitWithdrawal(input: SubmitWithdrawalInput, signal: AbortSignal): Promise<TxRef>;
+  /**
+   * Watches the settlement entity through its lifecycle (pending → succeeded / failed). The
+   * listener fires on every transition with the new envelope; the FSM consumes these via the
+   * snapshot subscribe path.
+   */
+  watchSettlement(input: WatchWithdrawalSettlementInput, listener: (entity: WithdrawSnapshot["settlement"]) => void, signal: AbortSignal): void;
+  /**
+   * Optional balances watcher — when supplied, the driver pushes withdrawable-balance updates
+   * into its own snapshot. Hosts that surface a static brand-side balance can omit this.
+   */
+  watchWithdrawableBalances?(input: WatchWithdrawableBalancesInput, listener: (entity: WithdrawSnapshot["withdrawableBalances"]) => void, signal: AbortSignal): void;
+}
+//#endregion
+export { RequestWithdrawalQuoteInput, SubmitWithdrawalInput, WatchWithdrawableBalancesInput, WatchWithdrawalSettlementInput, WithdrawDriver, WithdrawSnapshot };

package/dist/flows/withdraw/orchestrator/controller.d.ts

@@ -0,0 +1,11 @@
+import { WithdrawState } from "./types.js";
+import { ReactNode } from "react";
+//#region src/flows/withdraw/orchestrator/controller.d.ts
+/**
+ * Read the **logical** withdraw state — what the reducer says. Transitions to `closed` are
+ * surfaced synchronously, so this is the right hook for "is the dialog open?" gating, analytics,
+ * and any headless UI that drives off live machine state.
+ */
+declare function useWithdrawState(): WithdrawState;
+//#endregion
+export { useWithdrawState };

package/dist/flows/withdraw/orchestrator/controller.js

@@ -0,0 +1 @@
+"use client";import{useLingui as e}from"../../../shared/i18n/useLingui.js";import"../../../i18n/index.js";import{toFailure as t}from"../../../shared/orchestrator/toFailure.js";import{useDriverSettlementListener as n}from"../../../shared/orchestrator/useDriverSettlementListener.js";import{useEffectiveState as r}from"../../../shared/orchestrator/useEffectiveState.js";import{useSettlementWatcher as i}from"../../../shared/orchestrator/useSettlementWatcher.js";import"../../../shared/orchestrator/index.js";import{useWithdrawDriverInstance as a}from"../driver/context.js";import{initialState as o,reducer as s}from"./reducer.js";import{createContext as c,use as l,useCallback as u,useMemo as d,useReducer as f,useRef as p}from"react";import{jsx as m}from"react/jsx-runtime";const h={id:`ldK3jJ`,message:`Failed to submit withdrawal.`},g={id:`kUFhUv`,message:`Withdrawal failed.`},_=c(null);_.displayName=`WithdrawControllerContext`;function v(){let e=l(_);if(!e)throw Error(`useWithdraw / WithdrawControllerProvider must be used inside <KitProvider withdraw={…} />. Mount KitProvider once at the host's app root with a withdraw driver.`);return e}function y(){return v().state}function b(){return v().effectiveState}function x(){return v().actions}function S({children:e}){let t=a(),[n,c]=f(s,o),l=w(n,c,t);i(t,n.name===`inProgress`?n.ctx.tx:void 0),T(n,c,t);let u=r(n),p=C(c,l);return m(_,{value:d(()=>({state:n,effectiveState:u,dispatch:c,controller:p,actions:l}),[n,u,p,l]),children:e})}function C(e,t){let n=u(()=>{e({type:`OPEN`})},[e]),r=u(()=>{e({type:`CLOSE`})},[e]);return d(()=>({open:n,close:r,actions:t}),[n,r,t])}function w(n,r,i){let a=p(n);a.current=n;let o=p(i);o.current=i;let s=p(r);s.current=r;let{i18n:c}=e(),l=p(c);l.current=c;let f=u(e=>{let n=o.current;s.current({type:`SUBMIT`,input:e});let r=new AbortController,i={sourceAssetSymbol:e.sourceAssetSymbol,sourceChainId:e.sourceChainId,amount:e.amount,receiveTokenSymbol:e.receiveTokenSymbol,receiveChainId:e.receiveChainId,recipientAddress:e.recipientAddress};n.submitWithdrawal(i,r.signal).then(e=>{r.signal.aborted||s.current({type:`SUBMIT_CONFIRMED`,tx:e})}).catch(n=>{r.signal.aborted||s.current({type:`SUBMIT_FAILED`,failure:t(n,l.current._(h)),input:e})})},[]),m=u(()=>{s.current({type:`CLOSE`})},[]),g=u(()=>{s.current({type:`RESET`})},[]),_=u(()=>{s.current({type:`CLEAR_NOTICE`})},[]);return d(()=>({submit:f,close:m,reset:g,clearNotice:_}),[f,m,g,_])}function T(t,r,i){let a=p(t);a.current=t;let{i18n:o}=e(),s=p(o);s.current=o,n(i,(e,t)=>{if(a.current.name===`inProgress`){if(e===`succeeded`){r({type:`SETTLEMENT_SUCCEEDED`});return}if(e===`failed`){let e=t.settlement,n=e.status===`ready`||e.status===`stale`?e.payload:null,i=n&&n.kind===`failed`?{reason:s.current._(g),code:n.failureKind}:void 0;r({type:`SETTLEMENT_FAILED`,...i?{failure:i}:{}})}}})}export{S as WithdrawControllerProvider,v as useControllerContext,x as useWithdrawActions,b as useWithdrawEffectiveState,y as useWithdrawState};

package/dist/flows/withdraw/orchestrator/index.d.ts

@@ -0,0 +1,4 @@
+import { FailureInfo } from "../../../shared/orchestrator/types.js";
+import { WithdrawActions, WithdrawController, WithdrawEvent, WithdrawState, WithdrawStateName, WithdrawalFormSnapshot } from "./types.js";
+import { useWithdrawState } from "./controller.js";
+import { useWithdraw } from "./useWithdraw.js";

package/dist/flows/withdraw/orchestrator/index.js

@@ -0,0 +1 @@
+import"./controller.js";import"./useWithdraw.js";

package/dist/flows/withdraw/orchestrator/reducer.js

@@ -0,0 +1 @@
+import{isUserRejectionFailure as e}from"../../../shared/orchestrator/userRejection.js";import"../../../shared/orchestrator/index.js";const t={name:`closed`};function n(e,t){switch(e.name){case`closed`:return r(t);case`form`:return i(e,t);case`submitting`:return a(e,t);case`inProgress`:return o(e,t);case`success`:return s(e,t);case`error`:return c(e,t);default:return l(e)}}function r(e){return e.type===`OPEN`?{name:`form`}:{name:`closed`}}function i(e,t){switch(t.type){case`SUBMIT`:return{name:`submitting`,ctx:{input:t.input}};case`CLEAR_NOTICE`:return e.ctx?.notice?{name:`form`}:e;case`CLOSE`:return{name:`closed`};default:return e}}function a(t,n){switch(n.type){case`SUBMIT_CONFIRMED`:return{name:`inProgress`,ctx:{input:t.ctx.input,tx:n.tx}};case`SUBMIT_FAILED`:return e(n.failure)?{name:`form`,ctx:{notice:n.failure.reason}}:{name:`error`,ctx:{input:n.input,failure:n.failure}};case`CLOSE`:return{name:`closed`};default:return t}}function o(e,t){switch(t.type){case`SETTLEMENT_SUCCEEDED`:return{name:`success`,ctx:{input:e.ctx.input,tx:e.ctx.tx}};case`SETTLEMENT_FAILED`:return{name:`error`,ctx:{input:e.ctx.input,tx:e.ctx.tx,...t.failure?{failure:t.failure}:{}}};case`CLOSE`:return{name:`closed`};default:return e}}function s(e,t){switch(t.type){case`RESET`:return{name:`form`};case`CLOSE`:return{name:`closed`};default:return e}}function c(e,t){switch(t.type){case`RESET`:return{name:`form`};case`CLOSE`:return{name:`closed`};default:return e}}function l(e){throw Error(`Unhandled withdraw state: ${JSON.stringify(e)}`)}export{t as initialState,n as reducer};