@swype-org/react-sdk 0.2.323 → 0.2.357

package/dist/index.d.cts

@@ -77,6 +77,21 @@ interface Account {
     nickname?: string | null;
     /** Optional display logo URL, e.g. the selected Reown wallet icon. */
     logoURI?: string;
+    /**
+     * WalletConnect identity recovered server-side from the account's session
+     * configs. Present only for WalletConnect-typed accounts — used to
+     * pre-check chain support before any reauthorization session exists (e.g.
+     * "Not supported" rows on the deposit-source sheet). `approvedChainIds` is
+     * the EIP-155 set the wallet approved at its most recent pairing — ground
+     * truth that overrides a stale Reown registry entry (registry listings lag
+     * the chains wallets actually support, e.g. newly launched mainnets).
+     */
+    walletConnect?: {
+        name: string;
+        reownWalletId?: string;
+        imageUrl?: string;
+        approvedChainIds?: number[];
+    };
     wallets: Wallet[];
     /** Remaining One-Tap allowance in USD, or null when not configured. */
     remainingAllowance?: number | null;
@@ -993,6 +1008,29 @@ interface ExecuteActionOptions {
     sessionId?: string;
     /** WalletConnect account/runtime key that owns this action. */
     walletConnectRuntimeKey?: string;
+    /**
+     * Chain id the WalletConnect OPEN_PROVIDER pairing must include (e.g. the
+     * reauth target token's chain). Overrides `action.metadata.requiredChainId`.
+     * A session reuse that doesn't approve this chain re-pairs with it required,
+     * and a pairing that comes back without it fails with a clear error instead
+     * of letting SELECT_SOURCE hit the backend's approved-chain validation.
+     */
+    walletConnectRequiredChainId?: number;
+    /**
+     * Human-readable name for `walletConnectRequiredChainId` (e.g. "HyperEVM"),
+     * used in the missing-required-chain error so users see the network name
+     * rather than a bare numeric chain id.
+     */
+    walletConnectRequiredChainLabel?: string;
+    /**
+     * EVM chain ids (from the backend's `/v1/chains`) proposed as optional
+     * namespaces in the WalletConnect pairing, on top of the runtime's
+     * hardcoded fallback. Keeps the proposal in sync with admin-managed source
+     * chains so a supporting wallet can approve them — chains missing from the
+     * proposal can never land in `approvedChainIds` and would be falsely
+     * reported as unsupported. The runtime remembers the list for re-pairs.
+     */
+    walletConnectOptionalChainIds?: number[];
     /**
      * Forwarded to APPROVE_SPL: invoked once after the Phantom signature is
      * returned and before client-side on-chain confirmation begins. The
@@ -1002,6 +1040,16 @@ interface ExecuteActionOptions {
     onApproveSplConfirming?: (action: AuthorizationAction) => void;
     /** Emits the WalletConnect pairing URI so UI can render a QR/deeplink while connect is pending. */
     onWalletConnectDisplayUri?: (uri: string) => void;
+    /**
+     * Mobile only: foreground the ALREADY-CONNECTED WalletConnect wallet so the
+     * pending signing prompt surfaces, WITHOUT re-pairing. Fired immediately
+     * before each WC signing RPC (APPROVE_PERMIT2 / SIGN_PERMIT2 / EXECUTE_BRIDGE).
+     * The executor has no wallet-deeplink metadata, so the caller supplies this
+     * side-effect (e.g. `triggerDeeplink('rainbow://')`). No-op on desktop, where
+     * the caller passes `undefined` (signing happens in the same paired wallet /
+     * extension and a QR is shown for cross-device).
+     */
+    onWalletConnectForegroundWallet?: () => void;
     /**
      * Optional Promise resolved by an external (non-WC) connection that races the
      * WalletConnect pairing for `OPEN_PROVIDER`. Currently used by
@@ -1055,6 +1103,7 @@ interface UseAuthorizationExecutorResult {
         paymasterUrl?: string;
         walletConnectRuntimeKey?: string;
         onWalletConnectDisplayUri?: (uri: string) => void;
+        onWalletConnectForegroundWallet?: () => void;
     }) => Promise<BatchedWalletCallsResult>;
     /** Refresh wallet capabilities and return whether atomicBatch is supported. */
     canBatch: () => Promise<boolean>;
@@ -1178,6 +1227,51 @@ interface OrchestratorRunOptions {
     onApproveSplConfirming?: (action: AuthorizationAction) => void;
     /** Emits the direct WalletConnect pairing URI while OPEN_PROVIDER is connecting. */
     onWalletConnectDisplayUri?: (uri: string) => void;
+    /**
+     * Mobile only: foreground the ALREADY-CONNECTED WalletConnect wallet before
+     * each signing prompt (APPROVE_PERMIT2 / SIGN_PERMIT2 / EXECUTE_BRIDGE) via a
+     * bare deeplink — over the live session, NOT a re-pair. Supplied by
+     * `handleSelectWalletConnectWallet` / the reauth handlers, which hold the
+     * wallet's deeplink metadata. Omitted on desktop (QR + same-wallet signing).
+     */
+    onWalletConnectForegroundWallet?: () => void;
+    /**
+     * Pins ONE WalletConnect runtime key for the entire run, overriding the
+     * per-action resolution (`action.metadata.walletConnectAccountId` / tracked
+     * `session.accountId`). Supplied by the handler that performed the pairing
+     * (it knows the client `accountId` it paired under). Guarantees pairing
+     * (OPEN_PROVIDER) and signing (APPROVE_PERMIT2 / SIGN_PERMIT2 / EXECUTE_BRIDGE)
+     * use the SAME module-level runtime Map entry — closing the gap where
+     * `session.accountId` is null at OPEN_PROVIDER but non-null by APPROVE_PERMIT2,
+     * which otherwise makes signing look up a fresh, unpaired runtime and re-pair
+     * (a second QR / connection approval).
+     */
+    walletConnectRuntimeKey?: string;
+    /**
+     * Chain id the WalletConnect OPEN_PROVIDER pairing must include — the
+     * reauth target token's chain, supplied by the token-authorization
+     * handlers. Overrides `action.metadata.requiredChainId` so the SDK can
+     * require the right chain even when the backend didn't stamp it. A
+     * session that doesn't approve this chain re-pairs with it required; a
+     * pairing that still comes back without it fails OPEN_PROVIDER with a
+     * clear error instead of crashing SELECT_SOURCE auto-resolve on the
+     * backend's approved-chain validation (422 INVALID_SELECT_SOURCE_SELECTION).
+     */
+    walletConnectRequiredChainId?: number;
+    /**
+     * EVM chain ids from the backend's `/v1/chains`, proposed as optional
+     * namespaces at the WalletConnect pairing on top of the runtime's hardcoded
+     * fallback. Source chains are admin-managed server-side, so deriving the
+     * proposal from this list keeps newly-enabled chains approvable without an
+     * SDK release — a chain absent from the proposal can never be approved and
+     * would surface as a false "Not supported" row.
+     */
+    walletConnectOptionalChainIds?: number[];
+    /**
+     * Human-readable name for `walletConnectRequiredChainId` (e.g. "HyperEVM"),
+     * surfaced in the missing-required-chain error instead of a bare chain id.
+     */
+    walletConnectRequiredChainName?: string;
     /**
      * Optional Promise that races the WalletConnect pairing for OPEN_PROVIDER.
      * Used by `handleSelectWalletConnectWallet` when the picked Reown wallet is
@@ -1220,6 +1314,18 @@ interface UseAuthorizationOrchestratorResult {
     pendingSelectSourceAction: AuthorizationAction | null;
     /** Complete the pending SELECT_SOURCE action with a chosen source. */
     resolveSelectSource: (selection: SourceSelection) => void;
+    /**
+     * True once an INTERACTIVE SELECT_SOURCE has been resolved during the
+     * current run (i.e. the user picked a token on LinkTokensScreen and tapped
+     * Approve via `resolveSelectSource`). Reset to false at the start of each
+     * `run` and on `cancelPendingFlow`. The `autoResolveSource` path (WC
+     * reauthorization / token authorization) never sets this, because it
+     * resolves SELECT_SOURCE without pausing for the user. Consumed by
+     * StepRenderer to distinguish the post-Approve transient (where the
+     * executor's `currentAction` is still the stale OPEN_PROVIDER from pairing)
+     * from genuine pairing — so OpenWalletScreen doesn't flash after Approve.
+     */
+    sourceSelectionResolved: boolean;
     /** True after the most recent run drained all authorization actions. */
     orchestratorCompleted: boolean;
     /** Cancel any paused setup flow and reject the current orchestrator run. */
@@ -1276,6 +1382,20 @@ interface PreparedTokenAuthorization {
     providerId: string | null;
     providerName: string;
     depositAmount: number;
+    /**
+     * Present when the target account is WalletConnect-typed. There is no
+     * native wallet deeplink for WC, and the auth-app session URI cannot
+     * execute a WalletConnect session (it would strand the user on a loading
+     * LinkTokensScreen) — committing such a prepared authorization must run
+     * the inline WC orchestrator path in this tab instead. `deeplinkUri` is
+     * empty in this case and must not be navigated to.
+     */
+    walletConnect?: {
+        /** Reown metadata recovered from the session's OPEN_PROVIDER action. */
+        metadata: WalletConnectAccountMetadata | null;
+        /** Wallet name used for open-wallet branding and button copy. */
+        displayName: string;
+    };
 }
 
 /** Snapshot for restoring deposit source after cancelling token reauth / increase-limit subflows. */
@@ -1345,6 +1465,13 @@ interface PaymentState {
         providerId: string | null;
         walletName?: string;
         walletLogoUrl?: string;
+        /**
+         * Bare WalletConnect wallet deeplink (no `wc:` pairing URI) used to
+         * FOREGROUND the already-connected wallet for a signing prompt on mobile.
+         * Powers the manual "Open {wallet}" button on `ApprovingInWalletScreen`.
+         * Distinct from `sessionUri` (the pairing QR/deeplink).
+         */
+        walletForegroundLink?: string;
     } | null;
     /**
      * Active authorization session id for the in-progress wallet-setup flow.
@@ -1519,6 +1646,13 @@ interface StepHandlers {
     onFinalizeAmount: () => void;
     onSetDepositToken: (symbol: string, chainName: string, walletId?: string, tokenAddress?: string, chainId?: number) => void;
     onConfirmSetupDeposit: () => void | Promise<void>;
+    /**
+     * Mobile only: foreground the already-connected WalletConnect wallet from the
+     * signing screen's manual "Open {wallet}" button. Opens the bare wallet
+     * deeplink (no `wc:` URI) so the pending Permit2 prompt surfaces without
+     * re-pairing. Undefined on desktop / when no foreground link is available.
+     */
+    onOpenWalletForeground?: () => void;
 }
 /** Flow identity: reducer state, auth, layout. */
 interface StepRendererFlowProps {
@@ -1566,10 +1700,25 @@ interface StepRendererRemoteProps {
     /** True while `executeSessionById` is running (desktop inline wallet steps). */
     authExecutorExecuting: boolean;
     authExecutorCurrentAction?: AuthorizationAction | null;
+    /** True once a run has drained all authorization actions (orchestrator
+     *  completed). Stays true through the post-sign settling window — when
+     *  `currentAction` is already null — until the next run resets it. Lets the
+     *  approving checklist render all items complete instead of reverting to the
+     *  default active state while the next screen loads. */
+    authExecutorCompleted: boolean;
     transferSigningSigning: boolean;
     transferSigningError: string | null;
     transferSigningPasskeyDismissed?: boolean;
     pendingSelectSource: AuthorizationAction | null;
+    /**
+     * True once the user interactively resolved a SELECT_SOURCE this run (picked
+     * a token on LinkTokensScreen and tapped Approve). Distinguishes the
+     * post-Approve transient — where the executor's `currentAction` is still the
+     * stale OPEN_PROVIDER from pairing — from genuine pairing, so OpenWalletScreen
+     * is not re-shown after Approve. False during WC reauthorization auto-resolve
+     * pairing, which keeps OpenWalletScreen visible until the wallet pairs.
+     */
+    sourceSelectionResolved: boolean;
 }
 /** Values derived from accounts / selection (plus select-source picker data). */
 interface StepRendererDerivedProps {
@@ -1581,11 +1730,19 @@ interface StepRendererDerivedProps {
     selectedAccount: Account | undefined;
     selectedSource: WalletSource | null;
     selectSourceChoices: SelectSourceChainChoice[];
+    /** Balances on chains the WalletConnect session did not approve — rendered as disabled "Not supported" rows. */
+    selectSourceUnsupportedChoices: SelectSourceChainChoice[];
     selectSourceRecommended: {
         chainName: string;
         tokenSymbol: string;
     } | null;
     selectSourceAvailableBalance: number;
+    /**
+     * Reown registry chain ids per WalletConnect-typed account id (null =
+     * registry has no opinion, fail open). Used to badge requires-auth deposit
+     * sources on chains the backing wallet cannot authorize.
+     */
+    walletConnectChainIdsByAccount: Record<string, number[] | null>;
 }
 /** Ephemeral form UI state. */
 interface StepRendererFormProps {
@@ -1753,8 +1910,25 @@ interface ScreenLayoutProps {
      * surrounding chrome (heading, banners, CTA) stays pinned. Defaults to true.
      */
     scrollableBody?: boolean;
+    /**
+     * When true, the footer floats over the body instead of taking its own band
+     * at the bottom of the sheet. Its background is a gradient that is
+     * transparent across the top half and fades to the solid sheet color for the
+     * bottom half, so the scroll content peeks through above the CTA while the
+     * button itself sits on a solid base. Only the footer's own children are
+     * interactive — the transparent gutter passes taps and scroll through to the
+     * list below. Screens that opt in must reserve bottom padding in their scroll
+     * container so the last row clears the floating footer. Defaults to false.
+     */
+    floatingFooter?: boolean;
+    /**
+     * When true, the body still scrolls but its scrollbar is visually hidden
+     * (overflow behaviour is unchanged). Use for screens that should never show
+     * scrollbar chrome. Defaults to false.
+     */
+    hideScrollbar?: boolean;
 }
-declare function ScreenLayout({ children, footer, scrollableBody }: ScreenLayoutProps): react_jsx_runtime.JSX.Element;
+declare function ScreenLayout({ children, footer, scrollableBody, floatingFooter, hideScrollbar }: ScreenLayoutProps): react_jsx_runtime.JSX.Element;
 
 interface ScreenHeaderProps {
     /** Center title text */
@@ -1997,13 +2171,18 @@ interface PasskeyScreenProps {
 declare function PasskeyScreen({ onCreatePasskey, onBack, onLogout, creating, error, popupFallback, onCreatePasskeyViaPopup, onCreateNewPasskey, onCreateNewPasskeyViaPopup, createNewPopupFallback, creatingNewPasskey, }: PasskeyScreenProps): react_jsx_runtime.JSX.Element;
 
 interface PasskeyPopupWelcomeScreenProps {
+    /** Begins passkey creation (Privy signup). */
     onCreatePasskey: () => void;
+    /** When set, renders an "or Sign in with passkey" secondary action for users who already have a passkey. */
+    onSignInWithPasskey?: () => void;
+    /** Disables the actions and shows the primary button's loading state. */
     creating?: boolean;
+    /** Error copy shown in a banner below the hero. */
     error?: string | null;
     onBack?: () => void;
     onLogout?: () => void;
 }
-declare function PasskeyPopupWelcomeScreen({ onCreatePasskey, creating, error, onBack, onLogout, }: PasskeyPopupWelcomeScreenProps): react_jsx_runtime.JSX.Element;
+declare function PasskeyPopupWelcomeScreen({ onCreatePasskey, onSignInWithPasskey, creating, error, onBack, onLogout, }: PasskeyPopupWelcomeScreenProps): react_jsx_runtime.JSX.Element;
 
 interface VerifyPasskeyScreenProps {
     onVerify: () => void;
@@ -2072,12 +2251,27 @@ interface SetupTokenOption {
     walletAddress?: string;
     /** Server-provided token logo URI from the catalog. Preferred over the local `TOKEN_LOGOS` map. */
     logoURI?: string | null;
+    /**
+     * WalletConnect-typed account only: the Reown registry says the backing
+     * wallet does not support this token's chain, so authorizing it would
+     * dead-end (the prepare/authorize handlers' pre-filter rejects it).
+     * Rendered as a disabled "Not supported, deposit manually" row. Never set
+     * on AUTHORIZED rows — those deposit via passkey without the wallet.
+     */
+    notSupported?: boolean;
 }
 
 interface LinkTokenEntry {
     tokenSymbol: string;
     chainName: string;
     balanceUsd: number;
+    /**
+     * WalletConnect-only: the connected wallet cannot sign on this token's
+     * chain (missing from both the session's approved chains and the Reown
+     * registry). Renders the "Not supported, deposit manually" pill and makes
+     * the row unselectable.
+     */
+    notSupported?: boolean;
 }
 interface LinkTokensScreenProps {
     entries: LinkTokenEntry[];
@@ -2384,12 +2578,27 @@ interface ApprovingInWalletScreenProps {
      *  'sign'    = approval done (this session or previously) → step 1 checked, step 2 active;
      *  'spl'     = single Solana delegate approval (one item). */
     step: 'approve' | 'sign' | 'spl';
+    /** When true, every checklist item renders complete (checked). Set during the
+     *  post-sign settling window so the checkmarks persist until the next screen
+     *  loads, rather than reverting to the active/pending default. `step` still
+     *  selects the shape (one SPL item vs. two EVM items). */
+    complete?: boolean;
     error?: string | null;
     onRetry?: () => void;
     /** Desktop-only escape hatch back to the previous screen. */
     onBack?: () => void;
     /** Desktop-only settings/logout action. */
     onLogout?: () => void;
+    /** Mobile WalletConnect: connected wallet name, for the "Open {wallet}" button. */
+    walletName?: string | null;
+    /**
+     * Mobile WalletConnect: bare wallet deeplink (no `wc:` URI) for the manual
+     * "Open {wallet}" button. Foregrounds the already-connected wallet so the
+     * pending signing prompt surfaces — does NOT re-pair. Absent on desktop.
+     */
+    foregroundDeeplink?: string | null;
+    /** Fires when the user taps "Open {wallet}" (opens `foregroundDeeplink`). */
+    onOpenWallet?: () => void;
 }
 /**
  * Activation surface rendered while the user signs the Permit2 / SPL
@@ -2397,7 +2606,7 @@ interface ApprovingInWalletScreenProps {
  * Shares chrome with LinkTokensScreen (header wordmark, h2 heading, recessed
  * card, footer lock banner) so the link → authorize steps read as one page.
  */
-declare function ApprovingInWalletScreen({ tokenSymbol, chainName, step, error, onRetry, onBack, onLogout, }: ApprovingInWalletScreenProps): react_jsx_runtime.JSX.Element;
+declare function ApprovingInWalletScreen({ tokenSymbol, chainName, step, complete, error, onRetry, onBack, onLogout, walletName, foregroundDeeplink, onOpenWallet, }: ApprovingInWalletScreenProps): react_jsx_runtime.JSX.Element;
 
 interface ConfirmSignScreenProps {
     walletName: string | null;