Error Codes

Every error code the ProphetX SDK can return — what causes it, whether it's retryable, and what your code should do.

Errors reach your code through three separate layers. Knowing which layer an error comes from tells you where to handle it.

LayerHow you receive itWhat it covers
Embed flow errorsonError(code, message) on a flow, on('error') / useEvents({ onError }), or the PROPHETX_ERROR postMessageSession problems at open, failed deposits and withdrawals, location re-checks, embed crashes. The codes are the embed's own.
SDK client errorsA rejected promise from auth.login() or the wallet client, or the SDK's error eventYour app talking to ProphetX through the SDK's built-in auth and wallet modules, and session refresh failures.
REST API errorsThe HTTP response body { "code": "...", "error": "..." }Only if your backend calls the ProphetX REST API directly. The SDK and the embed never forward these; at most, a provider's reason appears inside an embed error's message.

Some outcomes are not errors and have their own callbacks: onGeofenceBlocked (location blocked when the flow opens), onKycFailed (document verification rejected) and onOneClickFailed / onOneClickDeclined (1-Click Signup).

circle-info

The message is for your logs, not for the user. It can be raw transport text (for example Request failed with status code 400: POST https://…) or a provider's own wording, and the embed has already shown the user a translated error screen. Branch on code, which is stable; never match on message.

Don't close the modal on onError. Most errors leave the embed on its own error screen, often with Try again. The modal closes when the user taps Close there, which fires onCancel. The tables below say what the embed shows for each code.

Embed error shape

The sections from Session errors through Other embed errors are embed flow errors. Each one arrives as:

onError: (code: string, message: string) => void

With the low-level postMessage protocol, the same error arrives as:

{
  "type": "PROPHETX_ERROR",
  "payload": {
    "code": "DEPOSIT_FAILED",
    "message": "Request failed with status code 400: POST https://…"
  }
}

Session errors

These fire when the flow opens and the embed can't establish a valid session. They point at your token endpoint or origin setup, not at anything the user can fix.

CodeDetected byRetry in place?Cause
SESSION_EXPIREDThe embed's token check, or the serverNo — reopenThe token's exp was already in the past when the flow opened
SESSION_INVALIDThe embed's token check, or the serverNoMalformed JWT, bad signature, wrong issuer, or any other rejection by GET /embed/v1/token/validate
ORIGIN_UNAUTHORIZEDThe embed (no HTTP request)NoYour page's origin isn't on the allowlist for this environment

The embed accepts only the first PROPHETX_SESSION it receives, so none of these can be fixed by sending another token to the same iframe.

SESSION_EXPIRED

Embed tokens are short-lived (10 minutes by default). This code means the token was already expired when the flow opened — for example, a token minted long before the user tapped Deposit.

What to do: Close the flow and open it again with a fresh token. Mint the token right before you open the flow.

A token that expires while the flow is open is handled differently: the embed asks for a new one (PROPHETX_SESSION_EXPIRED), and the SDK calls your onSessionExpired handler, or the auth module's getCredentials, to get it. If that handler returns null, throws, or takes longer than 10 seconds, the embed shows its session-expired screen and sends nothing further — onError does not fire. A handler that throws is reported on the SDK's error event as SESSION_REFRESH_FAILED (see SDK client errors).

<ProphetXProvider
  environment="sandbox"
  token={token}
  onSessionExpired={async () => {
    const res = await fetch("/api/prophetx-token");
    const { token } = await res.json();
    setToken(token);
    return token; // within 10 seconds, or the flow stops
  }}
>
  <App />
</ProphetXProvider>

SESSION_INVALID

The token failed validation — either client-side (malformed JWT, missing claims) or server-side (bad signature, unrecognized issuer). GET /embed/v1/token/validate returns a bare 401 with no response body in this case, so the specific cause isn't returned over the wire — investigate from your side.

What to do: Do not retry with the same token. ProphetX signs embed tokens, not you: your backend gets one from GET /private/v1/tokens (see Embedded UI). So check how the token reaches the SDK:

  • Pass the token exactly as GET /private/v1/tokens returned it. Don't decode, re-sign or edit it.
  • Mint it with the right partner credentials for the environment you're pointing the SDK at. A sandbox token is rejected by production, and the reverse.
  • Mint it for the user who is opening the flow.

ORIGIN_UNAUTHORIZED

The embed checks your page's origin against the allowlist ProphetX configures for each environment. The check runs in the embed, after the token itself has been validated, so an expired token reports SESSION_EXPIRED first.

What to do: Register your origin with ProphetX. This is a one-time setup per domain. If you're seeing this in development, make sure your localhost origin (including port) is registered. See Deposits and Withdrawals — Before you begin.

User prerequisite and permission errors

The embed validates the user's session via GET /embed/v1/token/validate, which returns the same gates and permissions objects available on the embed token itself:

{
  "expiration": "2026-06-15T16:30:00Z",
  "isvId": "80c7cadf-22e4-4752-b821-ef3e2c8f6cb4",
  "userId": "4874c17c-d991-496e-b29c-c7bdba87698d",
  "gates": {
    "kyc":           { "completed": true, "description": "Passed KYC" },
    "terms":         { "completed": true, "description": "Accepted terms and conditions" },
    "email-verify":  { "completed": true, "description": "Email address verified" },
    "phone-verify":  { "completed": true, "description": "Phone number verified" },
    "not-suspended": { "completed": true, "description": "Account is not suspended" }
  },
  "permissions": {
    "market-order":      { "granted": true,  "description": "Submit market orders" },
    "parlay":            { "granted": true,  "description": "Submit parlay orders" },
    "deposit-aeropay":   { "granted": true,  "description": "Deposit via AeroPay" },
    "withdraw-aeropay":  { "granted": true,  "description": "Withdraw via AeroPay" },
    "deposit-pnm-card":           { "granted": true, "description": "Deposit by debit card" },
    "deposit-pnm-apple-pay":      { "granted": true, "description": "Deposit by Apple Pay" },
    "deposit-pnm-google-pay":     { "granted": true, "description": "Deposit by Google Pay" },
    "deposit-pnm-cash-at-retail": { "granted": true, "description": "Deposit by cash at retail" },
    "withdraw-pnm-card":          { "granted": true, "description": "Withdraw to a debit card" },
    "deposit-zerohash":  { "granted": false, "denyReason": "Blocked in NY", "description": "Deposit via ZeroHash" },
    "withdraw-zerohash": { "granted": false, "denyReason": "Blocked in NY", "description": "Withdraw via ZeroHash" }
  }
}

There are five gates: kyc, terms, email-verify, phone-verify, not-suspended. Geofencing is handled separately from this gate list — see GEOFENCE_BLOCKED below.

The embed builds its list of payment methods from permissions: it shows a method only when its deposit-… or withdraw-… permission is granted, plus Wire Transfer, which is always shown.

circle-info

KYC is not a special case. Unlike a previous version of this page, gates.kyc.completed is not always true just because the user has a session token — kyc is one of the required gates for every deposit and withdraw permission, exactly like terms or not-suspended. There is no separate withdrawal-only KYC gate; the mechanism below covers deposits and withdrawals identically.

When a required gate is unmet, the SDK reports no error. The backend marks the affected payment permissions granted: false, so the deposit or withdraw screen opens with only the methods still granted — often just Wire Transfer. onError doesn't fire, and there's no pending_gates list in the SDK.

If you call the REST API directly, the same condition comes back as 403 PERMISSION_DENIED with a pending_gates array. The SDK and the embed never pass that code on.

So check gates and permissions from the validate response (or the token payload) before opening a deposit or withdraw flow, and route the user first:

Unmet gateRoute the user to
kycuseKyc/useIdUpload (document verification) — a session token means the user already exists, so a missing kyc gate means re-verification after an earlier FAILURE, not new-user signup. See Identity Verification.
termsThe /tandc route — see Terms flow.
email-verifyNo embedded flow today — verification is handled by your registration system or an out-of-band email link
phone-verifyNo embedded flow today — handle via your own OTP UI
not-suspendedNot user-resolvable — the account is suspended; direct the user to support
import { useDeposit, useIdUpload } from "@prophetx/sdk-react";

function DepositButton({ gates }) {
  const { open: openDeposit } = useDeposit();
  const { open: openIdUpload } = useIdUpload(); // or useKyc — same flow

  const start = () => {
    // gates: from your backend's GET /embed/v1/token/validate call
    if (!gates.terms.completed) return openTerms({ onAccepted: () => openDeposit() });
    if (!gates.kyc.completed) return openIdUpload({ onKycSuccess: () => openDeposit() });
    openDeposit();
  };

  return <button onClick={start}>Deposit</button>;
}

openTerms stands for your own handler that shows the /tandc route.

Provider-specific denials. A granted: false permission with a denyReason (e.g. deposit-zerohash blocked in NY) works the same way: the embed leaves that method off the list and fires no error. If every method you care about is denied, tell the user why using the denyReason from your validate call.

KYC_REQUIRED on withdraw, and a second GEOFENCE_BLOCKED channel

KYC_REQUIRED (Online Bank withdrawals only). The embed handles this code, but the ProphetX backend doesn't send it today. A user without a completed kyc gate isn't granted withdraw-aeropay, so Online Bank never appears in their withdrawal list (see above). A request that gets through anyway is refused by the gateway with 403 PERMISSION_DENIED, not KYC_REQUIRED.

If the embed ever receives 403 { "code": "KYC_REQUIRED" } on an AeroPay withdrawal, it shows a "Verification required" screen with a Close button and sends onError("KYC_REQUIRED", message). It can't be retried inside the flow: open useKyc/useIdUpload (this user already exists, so it's re-verification, not signup), then let the user try again once verified. Keeping a KYC_REQUIRED case in your handler is harmless; check the kyc gate before you open a flow and don't rely on this code.

GEOFENCE_BLOCKED. The location check runs twice, and each run reports through a different channel:

  1. When the flow opens: onGeofenceBlocked(stateCode, reason) / PROPHETX_GEOFENCE_BLOCKED, if the user's token says their location check didn't pass. Both arguments are currently always 'unknown'; show your own message.
  2. Just before a deposit or withdrawal is submitted: onError("GEOFENCE_BLOCKED", message). The embed re-validates the session here and fails closed, so this also fires when the session can't be re-validated — for example, the token expired while the user sat on the form. Reopen the flow with a fresh token before showing location messaging. The embed shows "Location not permitted" with a Close button, and onCancel follows when the user closes it.

There is no VPN detection; location comes from the token your backend mints.

Deposit and withdrawal provider errors

These are the codes the deposit and withdraw flows send through onError. The embed ships flows for AeroPay (Online Bank, deposit and withdraw), ZeroHash (Crypto, deposit only), and PayNearMe (Debit Card, Apple Pay, Google Pay and Cash at Retail deposits; withdrawal to a debit card already used for a deposit). There is no Trustly integration.

"What the embed shows" tells you whether the user can retry inside the modal. Where it offers Try again, don't close the modal yourself.

Deposit

CodeCauseWhat the embed showsWhat to do
DEPOSIT_FAILEDGeneric refusal by the deposit API. For Online Bank, message carries the backend's reasonError screen with Try again (or Go back, when AeroPay has blocked the user)Log it
DEPOSIT_UNCONFIRMEDThe submit's answer was lost and the deposit was never confirmed. It may still have gone through"Check your balance" screen with Try againRefresh the balance before the user retries
DEPOSIT_NOT_COMPLETEDThe deposit was submitted but settlement failed or was cancelled"Payment unavailable" with the reference, Close onlyLog the transaction ID
DEPOSIT_WALLET_WRITE_FAILEDThe provider took the money but the ProphetX wallet wasn't creditedError screen with Try againDon't let the user retry; send the transaction ID to ProphetX support to reconcile
PROVIDER_LOAD_FAILED / PROVIDER_UNAVAILABLEThe selected provider's widget didn't load, or the provider isn't available right now"Payment unavailable", Close onlyLet the user try a different method
PAYNEARME_DEPOSIT_FAILEDA debit card, Apple Pay, Google Pay or cash deposit failed: the session didn't open, PayNearMe declined it or errored, or the session expired. message is PayNearMe deposit failed (<PayNearMe code>)PayNearMe's own failure screen, with Try again where retrying can helpLog the code inside message
ZEROHASH_LOAD_FAILEDThe ZeroHash widget didn't load (often transient)Error screen with Try againLog it
ZEROHASH_PROVIDER_ERRORZeroHash reported a failure while funding"Payment unavailable", Close onlyLog it
ZEROHASH_DENIED / ZEROHASH_RESTRICTEDZeroHash refused the userIts own explanation, Close onlyDon't offer crypto again for this user
ZEROHASH_DETAILS_REQUIREDThe user's ProphetX record lacks the email or phone ZeroHash needsIts own explanation, Close onlyHave the user complete their profile, then retry
ZEROHASH_NOT_APPROVEDZeroHash hasn't approved the user yetIts own explanation, Close onlyRetry later
ZEROHASH_KYC_PENDINGZeroHash's identity check was still undecided when the embed stopped waitingError screen with Try againRetry later
ZEROHASH_DEPOSIT_CONFLICTThe same transaction ID was already recorded with a different amount, after ZeroHash moved the moneyError screen with Try againDon't retry; send the transaction ID to ProphetX support
GEOFENCE_BLOCKEDThe pre-submit location re-check failed, or the session couldn't be re-validated"Location not permitted", Close only (onCancel follows)Reopen with a fresh token — see above

Cash at Retail and Wire Transfer never send onSuccess: the user leaves with a barcode or instructions, and the flow ends with onCancel.

Withdrawal

CodeCauseWhat the embed showsWhat to do
WITHDRAWAL_FAILEDGeneric refusal by the withdrawal API. For Online Bank, message carries the backend's reasonError screen with Try again (or Go back, when AeroPay has blocked the user)Log it
WITHDRAWAL_UNCONFIRMEDThe submit's answer was lost and the withdrawal was never confirmed. Also sent for a PayNearMe withdrawal that couldn't be confirmed"Check your balance" screen with Try againRefresh the balance before the user retries
WITHDRAWAL_NOT_COMPLETEDThe withdrawal was submitted but settlement failed or was cancelledError screen with the reference and Try againLog the transaction ID
WITHDRAWAL_WALLET_WRITE_FAILEDThe payout went out but the ProphetX wallet wasn't debitedError screen with Try againDon't let the user retry; send the transaction ID to ProphetX support
PAYNEARME_WITHDRAWAL_FAILEDA withdrawal to a debit card failed. message is PayNearMe withdrawal failed (<PayNearMe code>)PayNearMe's own failure screen, with Try again where retrying can helpLog the code inside message
KYC_REQUIREDOnline Bank only: the user's identity isn't verified. Not sent by the backend today — see above"Verification required", Close onlyOpen useKyc/useIdUpload, then let them retry
PROVIDER_ERROR / ZEROHASH_PROVIDER_ERRORA provider widget inside the withdraw flow reported an errorError screen with Try againLog it
GEOFENCE_BLOCKEDThe pre-submit location re-check failed, or the session couldn't be re-validated"Location not permitted", Close only (onCancel follows)Reopen with a fresh token

A user with less than $1 available can't start a withdrawal: the embed tells them and the flow ends with onCancel, not an error.

Other embed errors

CodeCauseWhat to do
UNCAUGHT_ERRORAn unexpected runtime error inside the embed, caught by its error boundary. message is the raw error textLog it. The embed offers a retry. If it persists, send the details to ProphetX support
ROUTE_NOT_FOUNDThe iframe URL doesn't match any embed route (only possible when you build the URL yourself). message names the path; PROPHETX_READY never followsFix the URL

SDK client errors

These come from the SDK's own modules, not from a flow.

auth.login()

login() rejects with a ProphetXAuthError ({ type: 'AUTH_ERROR', code, message, status? }), and the auth state moves to error:

CodeWhen
INVALID_CREDENTIALSThe login endpoint returned 401
SERVER_ERRORAny other failed request — including timeouts and lost connections
NETWORK_ERRORThe login couldn't be processed at all (for example, the returned token couldn't be read)

TIMEOUT exists in the ProphetXAuthError type, but login() reports timeouts as SERVER_ERROR today. Don't rely on it.

Wallet

wallet.getBalance() (and useWallet().error) rejects with a ProphetXApiError: { type: 'API_ERROR', code, message, status }.

codestatusWhen
TIMEOUT0No response within 15 seconds
NETWORK_ERROR0The request couldn't reach the API (offline, DNS, CORS)
The backend's code, or HTTP_<status>The HTTP statusThe API answered with an error

SESSION_REFRESH_FAILED

Your onSessionExpired handler threw while the embed was waiting for a new token. The SDK reports it on its error event — sdk.on('error', …) or useEvents({ onError }) — with { code: 'SESSION_REFRESH_FAILED', message }, not on the flow's onError. The embed then shows its session-expired screen; reopen the flow with a fresh token.

REST API codes (direct API callers)

These codes appear in REST response bodies ({ "code": "...", "error": "..." }) when your backend calls ProphetX payment endpoints directly. The SDK never passes them to onError. If you only use the SDK, an Online Bank refusal reaches you as DEPOSIT_FAILED / WITHDRAWAL_FAILED with the backend's sentence in message, and a PayNearMe failure as PAYNEARME_*_FAILED with the PayNearMe code inside message.

CodeProviderRetryableCause
PERMISSION_DENIEDAnyNoA required gate is unmet; the body names them in pending_gates — see User prerequisite and permission errors
amount_mismatchAllNoThe amount for this transactionId doesn't match a prior request — mint a new transactionId and resubmit
insufficient_fundsAllNoWallet balance is too low for the requested withdrawal
aeropay_rejectedAeroPayYesAeroPay rejected the deposit or withdrawal request
user_unconfirmedAeroPayNoThe user hasn't completed AeroPay's SMS MFA confirmation yet — see Embedded UI
link_failedAeroPayYesBank-linking via Aerosync failed
mfa_rejectedAeroPayYesThe SMS MFA code was rejected. The code is a real SMS sent to the user's phoneNumber, even in sandbox; in sandbox only, 000000 is always accepted
invalid_amountPayNearMe, ZeroHashNoAmount is not a positive decimal with at most 2 places
participant_unconfirmedZeroHashNoThe user hasn't completed ZeroHash participant onboarding yet
missing_user_profileAeroPay, ZeroHashNoNo provider profile exists yet for this user — trigger the provider's onboarding step

PayNearMe codes are listed below. This is a representative list, not exhaustive — see each provider's section in Embedded UI for the full picture.

Errors raised inside the Aerosync bank-linking widget (for example INSTITUTION_ERROR / AC-148) are shown inside the widget and never sent to your page. They originate on AeroPay's side after ProphetX has issued a valid widget session, and usually track an AeroPay incident — retry, and report the user id and timestamp to ProphetX if it persists.

PayNearMe codes

These are every code the PayNearMe endpoints (/embed/v1/payment/pnm/*) return. Branch on code, not on the error text.

CodeStatusCauseWhat to do
pnm_rejected, pnm_find_orders_failed, pnm_smart_token_failed502Deposit: PayNearMe couldn't create or open the orderRetrying the same request is safe
tenant_unavailable503Payments aren't available right nowRetry later
invalid_amount400Amount isn't a positive decimal with at most 2 placesAsk for the amount again
payment_method_identifier_required400No card was chosen for the withdrawalAsk the user to pick a card
user_suspended400The account is suspended and can't withdrawRoute the user to support
user_profile_incomplete400A required profile field (name, date of birth, street, city, state, ZIP) is missingHave the user complete their profile, then retry
user_profile_unsupported_country400PayNearMe payouts are US-onlyFinal for this user; hide the withdraw option
pnm_push_user_rejected, pnm_push_order_rejected400PayNearMe refused the recipient or the payout setup; error has PayNearMe's reasonRoute the user to support
withdrawal_already_pending409Another withdrawal is waiting for reviewWait for it to finish
amount_mismatch, payment_method_identifier_mismatch409This transactionId was already used with a different amount or cardMint a new transactionId
withdrawal_settled409This transactionId was already paid out, rejected or declinedMint a new transactionId
payout_method_not_deposited422The card isn't one this user has deposited withAsk for another card
wallet_withdraw_failed422The amount couldn't be held: low balance, over the withdrawal limit, or suspended. Nothing was heldShow the reason; don't retry as is
pnm_push_order_failed502PayNearMe couldn't set up the payout. Nothing was heldRetry with a new transactionId
pnm_find_payment_methods_failed502GET .../withdraw/methods: PayNearMe couldn't list the payout methodsRetrying is safe
ops_approval_required403Returned by the deprecated POST .../withdraw/{transactionId}/executeDon't call it; see below

There is no execute step. A PayNearMe withdrawal is complete from your side once POST /embed/v1/payment/pnm/withdraw succeeds: ProphetX holds the amount, and the payout is sent when ProphetX operations approves it. The old execute endpoint is deprecated and always answers 403 ops_approval_required. This is the same whether the user withdraws in the embed or your backend calls the API.

Complete error handling example

One handler for the deposit and withdraw flows:

import { useCallback } from "react";
import { useIdUpload } from "@prophetx/sdk-react";

function useFlowErrorHandler() {
  const { open: openIdUpload } = useIdUpload(); // or useKyc — same flow

  return useCallback((code, message) => {
    // Always log: the message is for you, not the user
    analytics.track("flow_error", { code, message });

    switch (code) {
      // The session can't be fixed in this iframe: start over
      case "SESSION_EXPIRED":
      case "GEOFENCE_BLOCKED":
        reopenWithFreshToken();
        break;
      case "SESSION_INVALID":
      case "ORIGIN_UNAUTHORIZED":
        showContactSupport();
        break;

      // Online Bank withdrawal refused until the user re-verifies
      case "KYC_REQUIRED":
        openIdUpload({ onKycSuccess: () => showRetryPrompt() });
        break;

      // The outcome is unknown: show the latest balance
      case "DEPOSIT_UNCONFIRMED":
      case "WITHDRAWAL_UNCONFIRMED":
        refreshBalance();
        break;

      // Money moved but the wallet didn't update: needs support
      case "DEPOSIT_WALLET_WRITE_FAILED":
      case "WITHDRAWAL_WALLET_WRITE_FAILED":
      case "ZEROHASH_DEPOSIT_CONFLICT":
        refreshBalance();
        flagForSupport(code);
        break;

      // Everything else: the embed shows its own error or retry screen
      default:
        break;
    }
  }, [openIdUpload]);
}

// reopenWithFreshToken(), showContactSupport(), showRetryPrompt(),
// refreshBalance() and flagForSupport() are your own functions.
// Unmet gates produce no error: check them before opening a flow (see above).

Quick reference

Every code the SDK can send to onError, plus the SDK client codes.

CodeLayerFlowSummary
SESSION_EXPIREDEmbedAllToken already expired at open — reopen with a fresh token
SESSION_INVALIDEmbedAllBad or rejected JWT — pass the /private/v1/tokens token unchanged
ORIGIN_UNAUTHORIZEDEmbedAllOrigin not on the allowlist — contact ProphetX
GEOFENCE_BLOCKEDEmbedDeposit, withdrawPre-submit location re-check failed (or the session couldn't be re-validated)
DEPOSIT_FAILEDEmbedDepositGeneric refusal; embed offers Try again
DEPOSIT_UNCONFIRMEDEmbedDepositOutcome unknown — refresh the balance
DEPOSIT_NOT_COMPLETEDEmbedDepositSettlement failed or was cancelled
DEPOSIT_WALLET_WRITE_FAILEDEmbedDepositMoney moved, wallet not credited — support
PROVIDER_LOAD_FAILED / PROVIDER_UNAVAILABLEEmbedDepositProvider unavailable — try another method
PAYNEARME_DEPOSIT_FAILEDEmbedDepositPayNearMe failure; code inside message
ZEROHASH_* (8 codes)EmbedDepositCrypto deposit failures — see the deposit table
WITHDRAWAL_FAILEDEmbedWithdrawGeneric refusal; embed offers Try again
WITHDRAWAL_UNCONFIRMEDEmbedWithdrawOutcome unknown — refresh the balance
WITHDRAWAL_NOT_COMPLETEDEmbedWithdrawSettlement failed or was cancelled
WITHDRAWAL_WALLET_WRITE_FAILEDEmbedWithdrawPayout sent, wallet not debited — support
PAYNEARME_WITHDRAWAL_FAILEDEmbedWithdrawPayNearMe failure; code inside message
KYC_REQUIREDEmbedWithdraw (Online Bank)Identity not verified — open ID Upload. Not sent today
PROVIDER_ERROREmbedWithdrawProvider widget error
UNCAUGHT_ERROREmbedAllEmbed crashed — log and retry
ROUTE_NOT_FOUNDEmbed—Bad iframe URL
INVALID_CREDENTIALS / SERVER_ERROR / NETWORK_ERRORSDK clientauth.login()Login failed
TIMEOUT / NETWORK_ERROR / backend codeSDK clientWalletBalance request failed
SESSION_REFRESH_FAILEDSDK clienterror eventYour onSessionExpired handler threw


Did this page help you?