@swype-org/react-sdk 0.2.186 → 0.2.220

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode, MouseEvent, HTMLAttributeAnchorTarget } from 'react';
 
-type ChainFamily = 'evm' | 'svm';
+type ChainFamily = 'evm' | 'svm' | 'tvm';
 /** Wallet provider (e.g. MetaMask or Phantom) */
 interface Provider {
     id: string;
@@ -64,6 +64,8 @@ interface Account {
     name: string;
     /** Optional user-chosen display name for this account. */
     nickname?: string | null;
+    /** Optional display logo URL, e.g. the selected Reown wallet icon. */
+    logoURI?: string;
     wallets: Wallet[];
     /** Remaining One-Tap allowance in USD, or null when not configured. */
     remainingAllowance?: number | null;
@@ -92,6 +94,14 @@ interface AuthorizationAction {
     orderIndex: number;
     metadata?: Record<string, unknown>;
 }
+interface WalletConnectAccountMetadata {
+    reownWalletId: string;
+    name: string;
+    imageUrl?: string;
+    mobileNativeLink?: string;
+    mobileUniversalLink?: string;
+    desktopNativeLink?: string;
+}
 /** Full authorization session with ordered actions */
 interface AuthorizationSessionDetail {
     id: string;
@@ -194,7 +204,18 @@ interface ErrorResponse {
 interface ActionExecutionResult {
     actionId: string;
     type: string;
-    status: 'success' | 'error';
+    /**
+     * `pending` is a soft-halt sentinel: the action did not succeed, but it
+     * also did not produce a user-visible error. Used by `OPEN_PROVIDER` on
+     * desktop when no wallet extension is installed (or the user dismissed
+     * the connect prompt) and a parallel cross-device QR / auth-app path is
+     * still in flight. The session executor unwinds without throwing and
+     * the caller should not restore selection — `useDesktopWaitPollingEffect`
+     * (or the merchant's own polling) drives eventual completion.
+     */
+    status: 'success' | 'error' | 'pending';
+    /** When `status === 'pending'`, identifies the soft-halt reason. */
+    pendingReason?: 'awaiting-external-authorization';
     message: string;
     data?: unknown;
 }
@@ -210,6 +231,8 @@ interface SourceOption {
     rawBalance: string;
     walletId?: string;
     status?: string;
+    walletName?: string;
+    walletLogoUrl?: string;
 }
 /** User's chain+token selection for the SELECT_SOURCE action. */
 interface SourceSelection {
@@ -224,6 +247,49 @@ interface Destination {
         address: string;
     };
 }
+type ManualTransferStatus = 'awaiting_deposit' | 'deposit_received' | 'routing' | 'completed' | 'refunded' | 'failed' | 'wrong_token';
+interface ManualTransferSourceOption {
+    chainId: number;
+    chainName: string;
+    chainFamily: 'evm' | 'svm' | 'tvm';
+    tokenSymbol: string;
+    tokenAddress: string;
+    decimals: number;
+    minAmountUsd: string;
+}
+interface ManualTransferSlippageSnapshot {
+    estimatedOutput: string;
+    slippageValue: string;
+    slippagePercentage: string;
+    slippageValueCurrency: string;
+    createdAt: string;
+}
+interface ManualTransferSession {
+    sessionId: string;
+    idempotencyKey: string;
+    merchantId: string;
+    destination: Destination;
+    source: {
+        chainId: number;
+        tokenAddress: string;
+        tokenSymbol: string;
+    };
+    refundTo: string | null;
+    depositAddress: string;
+    requestId: string;
+    status: ManualTransferStatus;
+    minAmountUsd: string;
+    slippage: ManualTransferSlippageSnapshot | null;
+    quoteValidUntil: string;
+    depositTxHashes: string[];
+    destinationTxHash: string | null;
+    refundTxHashes: string[];
+    deliveredAmountUsd: string | null;
+    errorCode: string | null;
+    errorMessage: string | null;
+    createDate: string;
+    updateDate: string;
+}
 /** Merchant-signed authorization envelope required for transfer creation. */
 interface MerchantAuthorization {
     merchantId: string;
@@ -300,6 +366,7 @@ interface ThemeTokens {
     shadowLg: string;
     radius: string;
     radiusLg: string;
+    fontFamily: string;
 }
 declare const darkTheme: ThemeTokens;
 declare const lightTheme: ThemeTokens;
@@ -323,6 +390,27 @@ interface BlinkConfig {
     depositAmount: number | null;
     /** Update the deposit amount from a host-app component */
     setDepositAmount: (amount: number | null) => void;
+    /**
+     * When true, render the new full-widget entry experience (Deposit Options
+     * screen with Crypto/Cash toggle and source rows) before the login flow for
+     * unauthenticated users. Defaults to `false` for backwards compatibility.
+     *
+     * Optional on `BlinkConfig` so consumers of this type that pre-date the flag
+     * keep type-checking. Internal SDK code should normalize via
+     * `useBlinkConfig().enableFullWidget ?? false`.
+     */
+    enableFullWidget?: boolean;
+    /**
+     * When true, the SDK is being rendered inside a native mobile app's in-app
+     * browser (e.g. via `deposit-mobile-sdk` opening an SFSafariViewController
+     * or Android Custom Tab). Hides the in-screen (X) close buttons (the host
+     * app's native chrome handles dismissal) and removes the rounded screen
+     * sheet corners so the widget renders edge-to-edge. Defaults to `false`.
+     *
+     * Optional for backwards compatibility; internal SDK code normalizes via
+     * `useBlinkConfig().isMobileApp ?? false`.
+     */
+    isMobileApp?: boolean;
 }
 interface BlinkProviderProps {
     /** Base URL for the Blink API (e.g. "http://localhost:3000") */
@@ -340,6 +428,17 @@ interface BlinkProviderProps {
     privyAppId?: string;
     /** Minimum USD amount accepted when no payment-specific deposit amount is set. */
     minTransferAmountUsd?: number;
+    /**
+     * When true, render the new full-widget entry experience (DepositOptionsScreen)
+     * before login for unauthenticated users. Defaults to `false`.
+     */
+    enableFullWidget?: boolean;
+    /**
+     * When true, the widget is hosted inside a native mobile app's in-app browser.
+     * Hides the in-screen (X) close buttons and removes rounded screen corners so
+     * the widget renders edge-to-edge. Defaults to `false`.
+     */
+    isMobileApp?: boolean;
     children: React.ReactNode;
 }
 /**
@@ -356,7 +455,7 @@ interface BlinkProviderProps {
  * </BlinkProvider>
  * ```
  */
-declare function BlinkProvider({ apiBaseUrl, theme, privyAppId, minTransferAmountUsd, children, }: BlinkProviderProps): react_jsx_runtime.JSX.Element;
+declare function BlinkProvider({ apiBaseUrl, theme, privyAppId, minTransferAmountUsd, enableFullWidget, isMobileApp, children, }: BlinkProviderProps): react_jsx_runtime.JSX.Element;
 /** Access the Blink SDK configuration. Throws if used outside BlinkProvider. */
 declare function useBlinkConfig(): BlinkConfig;
 /**
@@ -395,6 +494,8 @@ interface CreateAccountParams {
      * {@link setAuthorizationSessionProvider} once the user taps a wallet.
      */
     providerId?: string;
+    connectionTransport?: 'walletconnect';
+    walletConnect?: WalletConnectAccountMetadata;
     /** Optional user-chosen display name. */
     nickname?: string;
     paymentIntent?: {
@@ -515,7 +616,29 @@ declare function setAuthorizationSessionProvider(apiBaseUrl: string, sessionId:
 declare function updateUserConfigBySession(apiBaseUrl: string, sessionId: string, config: {
     defaultAllowance: number;
 }): Promise<void>;
+interface FetchManualTransferSourcesParams {
+    merchantAuthorization: MerchantAuthorization;
+    destination: Destination;
+}
+declare function fetchManualTransferSources(apiBaseUrl: string, params: FetchManualTransferSourcesParams): Promise<ManualTransferSourceOption[]>;
+interface CreateManualTransferParams {
+    merchantAuthorization: MerchantAuthorization;
+    destination: Destination;
+    source: {
+        chainId: number;
+        tokenAddress: string;
+    };
+    idempotencyKey?: string;
+}
+declare function createManualTransfer(apiBaseUrl: string, params: CreateManualTransferParams): Promise<ManualTransferSession>;
+declare function fetchManualTransferSession(apiBaseUrl: string, sessionId: string): Promise<ManualTransferSession>;
 declare function reportActionCompletion(apiBaseUrl: string, actionId: string, result: Record<string, unknown>): Promise<AuthorizationSessionDetail>;
+interface ActionTransactionReceiptWaitResult {
+    txHash: string;
+    chainName: string;
+    status: 'success';
+}
+declare function waitForActionTransactionReceipt(apiBaseUrl: string, actionId: string, txHash: string): Promise<ActionTransactionReceiptWaitResult>;
 type ProbeActionCompletionResult = {
     detected: true;
     session: AuthorizationSessionDetail;
@@ -541,7 +664,9 @@ type ProbeActionCompletionResult = {
  * - `detected: false, reason: 'not-found'` — scan completed with no match
  *   (`DEPOSIT_TX_NOT_FOUND` for bridges, `APPROVE_NOT_DETECTED` for
  *   EVM approves, `APPROVE_SPL_NOT_DETECTED` for Solana approves); safe to
- *   prompt the wallet.
+ *   prompt the wallet only when no matching transaction may already have
+ *   been submitted. Post-submit callers must treat an approve miss as
+ *   inconclusive and avoid opening a duplicate approve prompt.
  * - `detected: false, reason: 'invalid-state'` — transfer already advanced
  *   past CREATED (race); the next orchestrator loop will observe it.
  * - `detected: false, reason: 'error'` — unexpected failure (network, 5xx);
@@ -555,20 +680,26 @@ type ProbeActionCompletionResult = {
  */
 declare function probeActionCompletion(apiBaseUrl: string, actionId: string): Promise<ProbeActionCompletionResult>;
 
+type api_ActionTransactionReceiptWaitResult = ActionTransactionReceiptWaitResult;
 type api_BridgeCall = BridgeCall;
 type api_CreateAccountAuthorizationSessionOptions = CreateAccountAuthorizationSessionOptions;
 type api_CreateAccountParams = CreateAccountParams;
+type api_CreateManualTransferParams = CreateManualTransferParams;
 type api_CreateTransferParams = CreateTransferParams;
+type api_FetchManualTransferSourcesParams = FetchManualTransferSourcesParams;
 type api_ProbeActionCompletionResult = ProbeActionCompletionResult;
 type api_TransferQuote = TransferQuote;
 declare const api_createAccount: typeof createAccount;
 declare const api_createAccountAuthorizationSession: typeof createAccountAuthorizationSession;
+declare const api_createManualTransfer: typeof createManualTransfer;
 declare const api_createTransfer: typeof createTransfer;
 declare const api_fetchAccount: typeof fetchAccount;
 declare const api_fetchAccounts: typeof fetchAccounts;
 declare const api_fetchAuthorizationSession: typeof fetchAuthorizationSession;
 declare const api_fetchAuthorizationSessionByToken: typeof fetchAuthorizationSessionByToken;
 declare const api_fetchChains: typeof fetchChains;
+declare const api_fetchManualTransferSession: typeof fetchManualTransferSession;
+declare const api_fetchManualTransferSources: typeof fetchManualTransferSources;
 declare const api_fetchMerchantPublicKey: typeof fetchMerchantPublicKey;
 declare const api_fetchProviders: typeof fetchProviders;
 declare const api_fetchTransfer: typeof fetchTransfer;
@@ -583,12 +714,16 @@ declare const api_setTransferSource: typeof setTransferSource;
 declare const api_signTransfer: typeof signTransfer;
 declare const api_updateUserConfig: typeof updateUserConfig;
 declare const api_updateUserConfigBySession: typeof updateUserConfigBySession;
+declare const api_waitForActionTransactionReceipt: typeof waitForActionTransactionReceipt;
 declare namespace api {
-  export { type api_BridgeCall as BridgeCall, type api_CreateAccountAuthorizationSessionOptions as CreateAccountAuthorizationSessionOptions, type api_CreateAccountParams as CreateAccountParams, type api_CreateTransferParams as CreateTransferParams, type api_ProbeActionCompletionResult as ProbeActionCompletionResult, type api_TransferQuote as TransferQuote, api_createAccount as createAccount, api_createAccountAuthorizationSession as createAccountAuthorizationSession, api_createTransfer as createTransfer, api_fetchAccount as fetchAccount, api_fetchAccounts as fetchAccounts, api_fetchAuthorizationSession as fetchAuthorizationSession, api_fetchAuthorizationSessionByToken as fetchAuthorizationSessionByToken, api_fetchChains as fetchChains, api_fetchMerchantPublicKey as fetchMerchantPublicKey, api_fetchProviders as fetchProviders, api_fetchTransfer as fetchTransfer, api_fetchUserConfig as fetchUserConfig, api_postTransferQuote as postTransferQuote, api_probeActionCompletion as probeActionCompletion, api_registerPasskey as registerPasskey, api_reportActionCompletion as reportActionCompletion, api_reportPasskeyActivity as reportPasskeyActivity, api_setAuthorizationSessionProvider as setAuthorizationSessionProvider, api_setTransferSource as setTransferSource, api_signTransfer as signTransfer, api_updateUserConfig as updateUserConfig, api_updateUserConfigBySession as updateUserConfigBySession };
+  export { type api_ActionTransactionReceiptWaitResult as ActionTransactionReceiptWaitResult, type api_BridgeCall as BridgeCall, type api_CreateAccountAuthorizationSessionOptions as CreateAccountAuthorizationSessionOptions, type api_CreateAccountParams as CreateAccountParams, type api_CreateManualTransferParams as CreateManualTransferParams, type api_CreateTransferParams as CreateTransferParams, type api_FetchManualTransferSourcesParams as FetchManualTransferSourcesParams, type api_ProbeActionCompletionResult as ProbeActionCompletionResult, type api_TransferQuote as TransferQuote, api_createAccount as createAccount, api_createAccountAuthorizationSession as createAccountAuthorizationSession, api_createManualTransfer as createManualTransfer, api_createTransfer as createTransfer, api_fetchAccount as fetchAccount, api_fetchAccounts as fetchAccounts, api_fetchAuthorizationSession as fetchAuthorizationSession, api_fetchAuthorizationSessionByToken as fetchAuthorizationSessionByToken, api_fetchChains as fetchChains, api_fetchManualTransferSession as fetchManualTransferSession, api_fetchManualTransferSources as fetchManualTransferSources, api_fetchMerchantPublicKey as fetchMerchantPublicKey, api_fetchProviders as fetchProviders, api_fetchTransfer as fetchTransfer, api_fetchUserConfig as fetchUserConfig, api_postTransferQuote as postTransferQuote, api_probeActionCompletion as probeActionCompletion, api_registerPasskey as registerPasskey, api_reportActionCompletion as reportActionCompletion, api_reportPasskeyActivity as reportPasskeyActivity, api_setAuthorizationSessionProvider as setAuthorizationSessionProvider, api_setTransferSource as setTransferSource, api_signTransfer as signTransfer, api_updateUserConfig as updateUserConfig, api_updateUserConfigBySession as updateUserConfigBySession, api_waitForActionTransactionReceipt as waitForActionTransactionReceipt };
 }
 
 interface BlinkPaymentProps {
     destination: Destination;
+    /** Dev/testing shortcut: skip directly to a specific screen on first render. */
+    initialScreen?: 'manual-transfer';
+    mock?: boolean;
     onComplete?: (transfer: Transfer) => void;
     onError?: (error: string) => void;
     useWalletConnector?: boolean;
@@ -608,18 +743,35 @@ interface SelectSourceChainChoice {
     tokens: {
         tokenSymbol: string;
         balance: number;
+        walletName?: string;
+        walletLogoUrl?: string;
     }[];
 }
 
-type ScreenName = 'loading' | 'login' | 'success' | 'processing' | 'confirm-sign' | 'select-source' | 'setup' | 'open-wallet' | 'setup-deposit' | 'passkey-ready' | 'wallet-picker' | 'token-picker' | 'guest-source-picker' | 'amount-too-low' | 'deposit';
+type ScreenName = 'loading' | 'manual-transfer' | 'login' | 'success' | 'processing' | 'confirm-sign' | 'select-source' | 'setup' | 'open-wallet' | 'setup-deposit' | 'passkey-ready' | 'wallet-picker' | 'token-picker' | 'guest-source-picker' | 'amount-too-low' | 'deposit' | 'deposit-options';
 interface MobileFlowState {
     deeplinkUri: string;
     providerId: string | null;
 }
+/**
+ * Desktop wait state — populated while the inline wagmi authorization executor
+ * is running and we want OpenWalletScreen to render a QR fallback so a user
+ * who has the wallet on their phone can complete via auth-app instead.
+ */
+interface DesktopWaitState {
+    sessionId: string;
+    sessionUri: string;
+    walletDeeplinks: WalletDeeplink[] | null;
+    providerId: string | null;
+}
 type PaymentPhase = {
     step: 'initializing';
+} | {
+    step: 'manual-transfer';
 } | {
     step: 'login';
+} | {
+    step: 'deposit-options';
 } | {
     step: 'data-loading';
 } | {
@@ -630,6 +782,7 @@ type PaymentPhase = {
 } | {
     step: 'wallet-setup';
     mobile: MobileFlowState | null;
+    desktopWait?: DesktopWaitState | null;
     accountId: string | null;
 } | {
     step: 'select-source';
@@ -664,7 +817,10 @@ type PaymentPhase = {
 declare function screenForPhase(phase: PaymentPhase): ScreenName;
 
 type WalletClient = {
-    request: (...args: any[]) => Promise<unknown>;
+    request: (args: {
+        method: string;
+        params?: unknown[];
+    }) => Promise<unknown>;
 };
 /**
  * Wallets report atomic batching support in two known formats:
@@ -703,7 +859,7 @@ interface WalletCapabilitiesDebugSnapshot {
  * Queries wallet_getCapabilities for the given address.
  * Returns an empty record if the wallet doesn't support EIP-5792.
  */
-declare function getWalletCapabilities(walletClient: WalletClient, address: string): Promise<WalletCapabilities>;
+declare function getWalletCapabilities(walletClient: WalletClient, address: string, chainId?: number | null): Promise<WalletCapabilities>;
 declare function getAtomicBatchSupportDebugInfo(capabilities: WalletCapabilities, chainId: number): AtomicBatchSupportDebugInfo;
 declare function supportsAtomicBatch(capabilities: WalletCapabilities, chainId: number): boolean;
 declare function supportsPaymasterService(capabilities: WalletCapabilities, chainId: number): boolean;
@@ -747,16 +903,44 @@ interface BatchedActionExecutionInput {
     action: AuthorizationAction;
     sessionId: string | null;
 }
-
+/**
+ * Result resolved by an external (non-WC) connect that may race the WalletConnect
+ * pairing — currently a wagmi `connectAsync` against an EIP-6963 extension that
+ * matches the picked Reown wallet. When this Promise resolves before WC pairs,
+ * the WC `connect()` is invalidated and we report the extension's wallet to the
+ * backend instead. The action result carries `transport: 'wagmi'` so the
+ * dispatcher flips `activeEvmTransportRef` to `'wagmi'` and the rest of the
+ * session's actions run through the wagmi branch (extension popups) rather than
+ * the WC runtime.
+ */
+interface WalletConnectExternalConnectResult {
+    accounts: readonly string[];
+    /** Numeric chain id (e.g. 8453 for Base). The executor formats it as 0x-hex. */
+    chainId: number;
+}
 type ExecutionResult = {
     status: 'completed';
 } | {
     status: 'cancelled';
+}
+/**
+ * Returned when an action returned a soft `pending` sentinel (e.g.
+ * desktop wait active and no wallet extension installed). The wagmi
+ * inline path has stopped without error; an external path
+ * (cross-device QR → auth-app → session polling) is expected to drive
+ * completion. Callers should leave `state.desktopWait` pinned and not
+ * restore selection.
+ */
+ | {
+    status: 'awaiting-external';
+    reason: string;
 };
 
 interface ExecuteActionOptions {
     /** Forwarded to actions that may need server polling (e.g. SIGN_PERMIT2 typedData). */
     sessionId?: string;
+    /** WalletConnect account/runtime key that owns this action. */
+    walletConnectRuntimeKey?: string;
     /**
      * Forwarded to APPROVE_SPL: invoked once after the Phantom signature is
      * returned and before client-side on-chain confirmation begins. The
@@ -764,6 +948,18 @@ interface ExecuteActionOptions {
      * cue while the SDK polls for `confirmed`.
      */
     onApproveSplConfirming?: (action: AuthorizationAction) => void;
+    /** Emits the WalletConnect pairing URI so UI can render a QR/deeplink while connect is pending. */
+    onWalletConnectDisplayUri?: (uri: string) => void;
+    /**
+     * Optional Promise resolved by an external (non-WC) connection that races the
+     * WalletConnect pairing for `OPEN_PROVIDER`. Currently used by
+     * `handleSelectWalletConnectWallet` to race a wagmi `connectAsync` against an
+     * EIP-6963 extension matching the picked Reown wallet. When this resolves
+     * before WC pairs, the executor invalidates the WC runtime and returns the
+     * extension's address with `transport: 'wagmi'`, which causes the dispatcher
+     * to flip `activeEvmTransportRef` so the rest of the session runs on wagmi.
+     */
+    walletConnectExternalConnect?: Promise<WalletConnectExternalConnectResult>;
 }
 interface UseAuthorizationExecutorResult {
     executing: boolean;
@@ -786,6 +982,8 @@ interface UseAuthorizationExecutorResult {
     resolveSelectSource: (selection: SourceSelection) => void;
     /** Reject paused SELECT_SOURCE and reset executor flags (e.g. user backed to deposit). */
     cancelPendingExecution: () => void;
+    /** Clear the persisted WalletConnect session so the next connection re-pairs. */
+    resetWalletConnect: (runtimeKey?: string) => Promise<void>;
     /** Transaction hash of the batched wallet_sendCalls, available after a successful batch. */
     batchTxHash: string | null;
     /**
@@ -803,6 +1001,8 @@ interface UseAuthorizationExecutorResult {
      */
     executeBatch: (actions: BatchedActionExecutionInput[], options?: {
         paymasterUrl?: string;
+        walletConnectRuntimeKey?: string;
+        onWalletConnectDisplayUri?: (uri: string) => void;
     }) => Promise<BatchedWalletCallsResult>;
     /**
      * SVM first-transfer combined path: signs the leading APPROVE_SPL +
@@ -842,6 +1042,14 @@ interface UseAuthorizationExecutorResult {
     addResult: (result: ActionExecutionResult) => void;
     /** Set the error message. */
     setError: (error: string | null) => void;
+    /**
+     * Toggle the soft-halt path for `OPEN_PROVIDER` no-connector / user-rejection
+     * outcomes. When `true`, those failure modes return a `pending` sentinel
+     * instead of an error so a parallel cross-device authorization (desktop
+     * QR scan → auth-app) can drive completion. `BlinkPayment` mirrors
+     * `state.desktopWait != null` into this flag.
+     */
+    setExternalAuthorizationAvailable: (available: boolean) => void;
     /**
      * Convenience wrapper: fetches a single session's actions, executes them,
      * and reports completions. Suitable for simple single-session flows.
@@ -880,6 +1088,19 @@ type OrchestratorResult = {
     status: 'completed';
 } | {
     status: 'cancelled';
+}
+/**
+ * Returned when an action returned a soft `pending` sentinel (currently
+ * only `OPEN_PROVIDER` on desktop when `state.desktopWait` is active and
+ * either no matching wallet extension is installed or the user dismissed
+ * the connect prompt). The wagmi inline loop has stopped without
+ * surfacing an error; an external path (cross-device QR / auth-app /
+ * session polling) is expected to drive completion. Callers should leave
+ * `state.desktopWait` pinned and not restore selection.
+ */
+ | {
+    status: 'awaiting-external';
+    reason: string;
 };
 interface OrchestratorRunOptions {
     /**
@@ -909,13 +1130,14 @@ interface OrchestratorRunOptions {
     alwaysPauseForOneTap?: boolean;
     /**
      * When true (default), before presenting the wallet for any of
-     * APPROVE_PERMIT2 / SIGN_PERMIT2 / APPROVE_SPL / EXECUTE_BRIDGE on this run, probe
+     * SIGN_PERMIT2 / APPROVE_SPL on this run, probe
      * the server to see if the action is already satisfied on-chain (e.g.
      * user confirmed pre-reload but the PATCH never landed, signed in
      * another tab, or the wallet returned a stale error after broadcasting).
+     * APPROVE_PERMIT2 is probed only after the orchestrator has evidence an
+     * approve transaction may already have been submitted.
      *
      * Probe semantics per action type:
-     *   - APPROVE_PERMIT2: backend re-checks ERC-20 allowance for Permit2.
      *   - SIGN_PERMIT2:    backend re-checks Permit2 allowance (single &
      *                      batched paths).
      *   - APPROVE_SPL:     backend re-checks SPL delegate authority.
@@ -941,6 +1163,21 @@ interface OrchestratorRunOptions {
      * surface for SDK consumers that drive their own UI.
      */
     onApproveSplConfirming?: (action: AuthorizationAction) => void;
+    /** Emits the direct WalletConnect pairing URI while OPEN_PROVIDER is connecting. */
+    onWalletConnectDisplayUri?: (uri: string) => void;
+    /**
+     * Optional Promise that races the WalletConnect pairing for OPEN_PROVIDER.
+     * Used by `handleSelectWalletConnectWallet` when the picked Reown wallet is
+     * also installed as an EIP-6963 extension: the SDK kicks off a wagmi
+     * `connectAsync` against the extension in parallel with the WC orchestrator
+     * run. Whichever resolves first wins; if the extension wins, the executor
+     * invalidates the WC runtime and the rest of the session executes via the
+     * wagmi branch.
+     */
+    walletConnectExternalConnect?: Promise<{
+        accounts: readonly string[];
+        chainId: number;
+    }>;
 }
 interface UseAuthorizationOrchestratorResult {
     /**
@@ -983,6 +1220,8 @@ interface UseAuthorizationOrchestratorResult {
     resolveOneTapPause: () => void;
     /** The awaiting-limit action currently waiting on one-tap setup. */
     pendingOneTapAction: AuthorizationAction | null;
+    /** True after the most recent run drained all authorization actions. */
+    orchestratorCompleted: boolean;
     /** Cancel any paused setup flow and reject the current orchestrator run. */
     cancelPendingFlow: () => void;
 }
@@ -992,6 +1231,26 @@ interface UseAuthorizationOrchestratorDeps {
 }
 declare function useAuthorizationOrchestrator(deps: UseAuthorizationOrchestratorDeps): UseAuthorizationOrchestratorResult;
 
+interface ReownWallet {
+    id: string;
+    name: string;
+    imageUrl?: string;
+    mobile?: ReownWalletLinks;
+    desktop?: ReownWalletLinks;
+    rdns?: string;
+    injected?: ReownInjectedWallet[];
+    chains?: string[];
+    sdks?: string[];
+}
+interface ReownWalletLinks {
+    native?: string;
+    universal?: string;
+}
+interface ReownInjectedWallet {
+    namespace?: string;
+    injectedId: string;
+}
+
 interface PreparedSession {
     uri: string;
     transferId?: string;
@@ -1057,6 +1316,24 @@ interface PaymentState {
      * (after setup Approve / token reauth). Cleared when the executor idles.
      */
     standardDesktopInlineOpenWallet: boolean;
+    /**
+     * Desktop standard flow: per-provider session URI and walletDeeplinks captured when the
+     * inline executor is dispatched. Drives the QR fallback on `OpenWalletScreen` so a
+     * desktop user with the wallet on their phone can complete via auth-app instead.
+     * Cleared when `standardDesktopInlineOpenWallet` is unpinned.
+     *
+     * `sessionId` is captured separately from `sessionUri` so the desktop polling
+     * effect can call `fetchAuthorizationSession(sessionId)` directly without
+     * having to parse the URI.
+     */
+    desktopWait: {
+        sessionId: string;
+        sessionUri: string;
+        walletDeeplinks: WalletDeeplink[] | null;
+        providerId: string | null;
+        walletName?: string;
+        walletLogoUrl?: string;
+    } | null;
     /**
      * Mobile flow: pin OpenWalletScreen (in loading mode) while
      * `createAccountAuthorizationSession` is in flight, i.e. between the
@@ -1102,10 +1379,19 @@ interface PaymentState {
     amountTooLow: {
         minAmountUsd: number;
     } | null;
+    /**
+     * When true, route unauthenticated users to `DepositOptionsScreen` (the new
+     * full-widget entry point) before login. Mirrored from `BlinkConfig` and
+     * preserved across `LOGOUT` so post-logout users still land on the
+     * options screen.
+     */
+    enableFullWidget: boolean;
 }
 interface InitialStateConfig {
     depositAmount: number | null;
     activeCredentialId: string | null;
+    initialPhase?: PaymentPhase;
+    enableFullWidget?: boolean;
 }
 declare function createInitialState(config: InitialStateConfig): PaymentState;
 
@@ -1114,6 +1400,7 @@ interface StepHandlers {
     onSignupWithPasskey: () => void;
     onPrepareProvider: (providerId: string) => Promise<PreparedSession | null>;
     onSelectProvider: (providerId: string, preparedSession?: PreparedSession) => Promise<void>;
+    onSelectWalletConnectWallet?: (wallet: ReownWallet) => Promise<void>;
     onContinueConnection: (accountId: string) => void;
     onSelectAccount: (accountId: string) => void;
     onPay: (amount: number, overrides?: {
@@ -1147,6 +1434,7 @@ interface StepHandlers {
     /** Leave funding subflow (setup / token picker) back to deposit: restore selection, cancel executor. */
     onBackFromSubflow: () => void;
     onLogin: () => void;
+    onCancelLogin: () => void;
     onSetDepositAmount: (amount: number) => void;
     onSetDepositToken: (symbol: string, chainName: string, walletId?: string, tokenAddress?: string, chainId?: number) => void;
     onConfirmSetupDeposit: () => void | Promise<void>;
@@ -1157,11 +1445,28 @@ interface StepRendererFlowProps {
     authenticated: boolean;
     passkeyLoading: boolean;
     isDesktop: boolean;
+    /**
+     * True when the SDK is hosted inside a native mobile app's in-app browser.
+     * Suppresses in-screen (X) close buttons (the host's native chrome handles
+     * dismissal) and removes rounded screen corners. Optional for backwards
+     * compatibility with pre-existing test fixtures; treated as `false` when
+     * absent.
+     */
+    isMobileApp?: boolean;
     merchantName?: string;
     onBack?: () => void;
     onDismiss?: () => void;
     depositAmount: number | null;
     minTransferAmountUsd: number;
+    /** Needed to render ManualTransferFlow when phase is manual-transfer. */
+    destination: Destination;
+    merchantAuthorization?: CreateManualTransferParams['merchantAuthorization'];
+    idempotencyKey?: string;
+    mock?: boolean;
+    /** Host-level completion callback, forwarded to ManualTransferFlow. */
+    onComplete?: (transfer: Transfer) => void;
+    /** Host-level error callback, forwarded to ManualTransferFlow. */
+    onError?: (error: string) => void;
 }
 /** Polling, signing, and auth-executor surface. */
 interface StepRendererRemoteProps {
@@ -1173,6 +1478,8 @@ interface StepRendererRemoteProps {
     authExecutorCurrentAction?: AuthorizationAction | null;
     /** SIGN_PERMIT2 action paused for one-tap setup; null until the limit screen is actionable. */
     pendingOneTapSetup?: AuthorizationAction | null;
+    /** True when all setup authorization actions for the active account/session are complete. */
+    setupAuthorizationComplete?: boolean;
     transferSigningSigning: boolean;
     transferSigningError: string | null;
     transferSigningPasskeyDismissed?: boolean;
@@ -1562,11 +1869,12 @@ interface WalletPickerScreenProps {
     directLinkCards?: boolean;
     onPrepareProvider: (providerId: string) => Promise<PreparedSession | null>;
     onSelectProvider: (providerId: string, preparedSession?: PreparedSession) => Promise<void>;
+    onSelectWalletConnectWallet?: (wallet: ReownWallet) => Promise<void>;
     onBack?: () => void;
     onLogout?: () => void;
     isDesktop?: boolean;
 }
-declare function WalletPickerScreen({ providers, loading, useDeeplink, error, preparedSessionsByProvider, preparingLinks, directLinkCards, onPrepareProvider, onSelectProvider, onBack, onLogout, isDesktop, }: WalletPickerScreenProps): react_jsx_runtime.JSX.Element;
+declare function WalletPickerScreen({ providers, loading, useDeeplink, error, preparedSessionsByProvider, preparingLinks, directLinkCards, onPrepareProvider, onSelectProvider, onSelectWalletConnectWallet, onBack, onLogout, isDesktop, }: WalletPickerScreenProps): react_jsx_runtime.JSX.Element;
 
 interface SetupScreenProps {
     onSetupOneTap: (limit: number) => void;
@@ -1732,6 +2040,8 @@ interface ChainChoice$1 {
     tokens: {
         tokenSymbol: string;
         balance: number;
+        walletName?: string;
+        walletLogoUrl?: string;
     }[];
 }
 interface SelectSourceScreenProps {
@@ -1756,6 +2066,8 @@ interface DepositSourceAccount {
     id: string;
     /** Provider / account name (e.g. "MetaMask"). Used to look up a logo via KNOWN_LOGOS. */
     name: string;
+    /** Optional account display logo, e.g. the selected Reown wallet icon. */
+    logoURI?: string;
     /** Full wallet address; a shortened suffix "...abcd" is shown on the right. */
     address?: string | null;
 }
@@ -1837,7 +2149,7 @@ type TransferPhase = 'creating' | 'signing' | 'submitting' | 'sent';
 interface TransferStatusBaseProps {
     phase: TransferPhase;
     error: string | null;
-    onLogout: () => void;
+    onLogout?: () => void;
     /**
      * Optional retry hook. Setup flows wire this to `orchestrator.restart()`;
      * deposit flows wire it only after the first passkey signing attempt fails.
@@ -1851,8 +2163,9 @@ interface TransferStatusBaseProps {
 interface SetupTransferStatusScreenProps extends TransferStatusBaseProps {
     depositAmount: number;
     tokenSymbol: string;
+    authorizationComplete?: boolean;
 }
-declare function SetupTransferStatusScreen({ phase, depositAmount, tokenSymbol, error, onLogout, onRetry, }: SetupTransferStatusScreenProps): react_jsx_runtime.JSX.Element;
+declare function SetupTransferStatusScreen({ phase, depositAmount, tokenSymbol, authorizationComplete, error, onLogout, onRetry, }: SetupTransferStatusScreenProps): react_jsx_runtime.JSX.Element;
 
 interface DepositTransferStatusScreenProps extends TransferStatusBaseProps {
     visibleError?: string | null;
@@ -1867,20 +2180,21 @@ interface OpenWalletScreenProps {
      *  When false (desktop), shows inline authorization progress instead. */
     useDeeplink?: boolean;
     error?: string | null;
+    walletLogoUrl?: string;
     onRetryStatus?: () => void;
     /** Soft-retry the orchestrator (calls `orchestrator.restart()`). Desktop only —
      *  shown alongside the error banner when set so the user can recover from a
      *  dismissed wallet popup without reloading the iframe. */
     onRetryAuthorization?: () => void;
     onBack?: () => void;
-    onLogout: () => void;
+    onLogout?: () => void;
 }
 /**
  * Wallet authorization screen. On mobile, provides a user-tappable button
  * that triggers the deeplink via window.open. On desktop, shows inline
  * authorization progress while wallet extension popups handle the flow.
  */
-declare function OpenWalletScreen({ walletName, deeplinkUri, loading, useDeeplink, error, onRetryStatus, onRetryAuthorization, onBack, onLogout, }: OpenWalletScreenProps): react_jsx_runtime.JSX.Element;
+declare function OpenWalletScreen({ walletName, deeplinkUri, loading, walletLogoUrl, useDeeplink, error, onRetryStatus, onRetryAuthorization, onBack, onLogout, }: OpenWalletScreenProps): react_jsx_runtime.JSX.Element;
 
 interface ConfirmSignScreenProps {
     walletName: string | null;