@stripe/stripe-react-native 0.57.0 → 0.57.2

package/src/hooks/useOnramp.tsx

@@ -0,0 +1,334 @@
+import { EventSubscription } from 'react-native';
+import NativeOnrampSdk from '../specs/NativeOnrampSdkModule';
+import { Onramp, OnrampError, StripeError } from '../types';
+import type { Address, PlatformPay } from '../types';
+import { useCallback } from 'react';
+import { addOnrampListener } from '../events';
+import { CryptoPaymentToken } from '../types/Onramp';
+
+let onCheckoutClientSecretRequestedSubscription: EventSubscription | null =
+  null;
+
+/**
+ * useOnramp hook
+ */
+export function useOnramp() {
+  const _configure = useCallback(
+    async (
+      config: Onramp.Configuration
+    ): Promise<{ error?: StripeError<OnrampError> }> => {
+      return NativeOnrampSdk.configureOnramp(config);
+    },
+    []
+  );
+
+  const _hasLinkAccount = useCallback(
+    async (email: string): Promise<Onramp.HasLinkAccountResult> => {
+      return NativeOnrampSdk.hasLinkAccount(email);
+    },
+    []
+  );
+
+  const _registerLinkUser = useCallback(
+    async (
+      info: Onramp.LinkUserInfo
+    ): Promise<Onramp.RegisterLinkUserResult> => {
+      return NativeOnrampSdk.registerLinkUser(info);
+    },
+    []
+  );
+
+  const _registerWalletAddress = useCallback(
+    async (
+      walletAddress: string,
+      network: Onramp.CryptoNetwork
+    ): Promise<{ error?: StripeError<OnrampError> }> => {
+      return NativeOnrampSdk.registerWalletAddress(walletAddress, network);
+    },
+    []
+  );
+
+  const _attachKycInfo = useCallback(
+    async (
+      kycInfo: Onramp.KycInfo
+    ): Promise<{ error?: StripeError<OnrampError> }> => {
+      return NativeOnrampSdk.attachKycInfo(kycInfo);
+    },
+    []
+  );
+
+  const _presentKycInfoVerification = useCallback(
+    async (updatedAddress: Address | null): Promise<Onramp.VerifyKycResult> => {
+      return NativeOnrampSdk.presentKycInfoVerification(updatedAddress);
+    },
+    []
+  );
+
+  const _authenticateUserWithToken = useCallback(
+    async (
+      linkAuthTokenClientSecret: string
+    ): Promise<{ error?: StripeError<OnrampError> }> => {
+      return NativeOnrampSdk.authenticateUserWithToken(
+        linkAuthTokenClientSecret
+      );
+    },
+    []
+  );
+
+  const _updatePhoneNumber = useCallback(
+    async (phone: string): Promise<{ error?: StripeError<OnrampError> }> => {
+      return NativeOnrampSdk.updatePhoneNumber(phone);
+    },
+    []
+  );
+
+  const _authenticateUser =
+    useCallback(async (): Promise<Onramp.AuthenticateUserResult> => {
+      return NativeOnrampSdk.authenticateUser();
+    }, []);
+
+  const _verifyIdentity = useCallback(async (): Promise<{
+    error?: StripeError<OnrampError>;
+  }> => {
+    return NativeOnrampSdk.verifyIdentity();
+  }, []);
+
+  /**
+   * The set of payment methods supported by crypto onramp collection.
+   * - 'Card' and 'BankAccount' present Link for collection.
+   * - 'PlatformPay' presents Apple Pay / Google Pay using provided params.
+   */
+  type OnrampPaymentMethod = 'Card' | 'BankAccount' | 'PlatformPay';
+
+  // Overloads for stronger type-safety at call-sites
+  const _collectPaymentMethod: {
+    (
+      paymentMethod: 'Card' | 'BankAccount',
+      platformPayParams?: undefined
+    ): Promise<Onramp.CollectPaymentMethodResult>;
+    (
+      paymentMethod: 'PlatformPay',
+      platformPayParams: PlatformPay.PaymentMethodParams
+    ): Promise<Onramp.CollectPaymentMethodResult>;
+  } = useCallback(
+    async (
+      paymentMethod: OnrampPaymentMethod,
+      platformPayParams?:
+        | PlatformPay.PaymentMethodParams
+        | Record<string, never>
+    ): Promise<Onramp.CollectPaymentMethodResult> => {
+      return NativeOnrampSdk.collectPaymentMethod(
+        paymentMethod,
+        (platformPayParams ?? {}) as any
+      );
+    },
+    []
+  );
+
+  const _createCryptoPaymentToken =
+    useCallback(async (): Promise<Onramp.CreateCryptoPaymentTokenResult> => {
+      return NativeOnrampSdk.createCryptoPaymentToken();
+    }, []);
+
+  const _performCheckout = useCallback(
+    async (
+      onrampSessionId: string,
+      provideCheckoutClientSecret: () => Promise<string | null>
+    ): Promise<{ error?: StripeError<OnrampError> }> => {
+      onCheckoutClientSecretRequestedSubscription?.remove();
+      onCheckoutClientSecretRequestedSubscription = addOnrampListener(
+        'onCheckoutClientSecretRequested',
+        async () => {
+          try {
+            const clientSecret = await provideCheckoutClientSecret();
+            NativeOnrampSdk.provideCheckoutClientSecret(clientSecret);
+          } catch (error: any) {
+            NativeOnrampSdk.provideCheckoutClientSecret(null);
+          }
+        }
+      );
+      return NativeOnrampSdk.performCheckout(onrampSessionId);
+    },
+    []
+  );
+
+  const _authorize = useCallback(
+    async (linkAuthIntentId: string): Promise<Onramp.AuthorizeResult> => {
+      return NativeOnrampSdk.onrampAuthorize(linkAuthIntentId);
+    },
+    []
+  );
+
+  const _getCryptoTokenDisplayData = useCallback(
+    async (
+      token: CryptoPaymentToken
+    ): Promise<Onramp.PaymentDisplayDataResult> => {
+      return NativeOnrampSdk.getCryptoTokenDisplayData(token);
+    },
+    []
+  );
+
+  const _logOut = useCallback(async (): Promise<{
+    error?: StripeError<OnrampError>;
+  }> => {
+    return NativeOnrampSdk.logout();
+  }, []);
+
+  const _isAuthError = (error: any): boolean => {
+    const stripeErrorCode = error?.stripeErrorCode;
+    const authErrorCodes = [
+      'consumer_session_credentials_invalid',
+      'consumer_session_expired',
+    ];
+    return authErrorCodes.includes(stripeErrorCode);
+  };
+
+  return {
+    /**
+     * Creates a `CryptoOnrampCoordinator` to facilitate authentication, identity verification, payment collection, and checkouts.
+     *
+     * @param config Configuration object containing merchant display name and appearance settings
+     * @returns Promise that resolves to an object with an optional error property
+     */
+    configure: _configure,
+
+    /**
+     * Whether or not the provided email is associated with an existing Link consumer.
+     *
+     * @param email The email address to look up
+     * @returns Promise that resolves to an object with hasLinkAccount boolean or error
+     */
+    hasLinkAccount: _hasLinkAccount,
+
+    /**
+     * Registers a new Link user with the provided details.
+     *
+     * @param info User information including email, phone, country, and optional full name
+     * @returns Promise that resolves to an object with customerId or error
+     */
+    registerLinkUser: _registerLinkUser,
+
+    /**
+     * Registers the given crypto wallet address to the current Link account.
+     * Requires an authenticated Link user.
+     *
+     * @param walletAddress The crypto wallet address to register
+     * @param network The crypto network for the wallet address
+     * @returns Promise that resolves to an object with an optional error property
+     */
+    registerWalletAddress: _registerWalletAddress,
+
+    /**
+     * Attaches the specific KYC info to the current Link user. Requires an authenticated Link user.
+     *
+     * @param kycInfo The KYC info to attach to the Link user
+     * @returns Promise that resolves to an object with an optional error property
+     */
+    attachKycInfo: _attachKycInfo,
+
+    /**
+     * Presents UI to verify KYC information for the current Link user.
+     * Requires the user to be authenticated with prior calls to either `authenticateUser` or `authorize`, and also requires prior KYC info attachement via `attachKycInfo`.
+     *
+     * @param updatedAddress: An optional updated address. Specify this parameter if the user has elected to change the address after a prior call to this API returned `UpdateAddress`. Otherwise, specify `null` to show the user's existing KYC information on the presented flow.
+     *
+     * @returns Promise that resolves to an instance of `VerifyKycResult` indicating whether the user confirmed their address, elected to update their address, cancelled the flow, or an error occurred.
+     */
+    presentKycInfoVerification: _presentKycInfoVerification,
+
+    /**
+     * Updates the user's phone number in their Link account.
+     *
+     * @param phone The new phone number to set for the user in E.164 format (e.g., +12125551234)
+     * @returns Promise that resolves to an object with an optional error property
+     */
+    updatePhoneNumber: _updatePhoneNumber,
+
+    /**
+     * Presents Link UI to authenticate an existing Link user.
+     * `hasLinkAccount` must be called before this.
+     *
+     * @returns Promise that resolves to an object with customerId or error
+     */
+    authenticateUser: _authenticateUser,
+
+    /**
+     * Authenticates the user with an encrypted Link auth token.
+     * This token can be obtained by exchanging a previously consented Link OAuth token from your backend using Stripe's /v1/link/auth_token API. The response of this backend API includes information on token expiry.
+     *
+     * @param linkAuthTokenClientSecret An encrypted one-time-use auth token that, upon successful validation, leaves the Link account’s consumer session in an already-verified state, allowing the client to skip verification.
+     * @returns Promise that resolves to an object with an optional error property if authentication fails due to an invalid token that is expired, already used, revoked, or not found, or if a network error occurs.
+     */
+    authenticateUserWithToken: _authenticateUserWithToken,
+
+    /**
+     * Creates an identity verification session and launches the document verification flow.
+     * Requires an authenticated Link user.
+     *
+     * @returns Promise that resolves to an object with an optional error property
+     */
+    verifyIdentity: _verifyIdentity,
+
+    /**
+     * Presents UI to collect/select a payment method of the given type.
+     *
+     * @param paymentMethod The payment method type to collect.
+     *  - 'Card' and 'BankAccount' present Link for collection.
+     *  - 'PlatformPay' presents Apple Pay / Google Pay using the provided parameters.
+     * @param platformPayParams Platform-specific parameters (required when `paymentMethod` is 'PlatformPay').
+     *  - iOS: provide `applePay` params
+     *  - Android: provide `googlePay` params
+     * @returns Promise that resolves to an object with displayData or error
+     */
+    collectPaymentMethod: _collectPaymentMethod,
+
+    /**
+     * Creates a crypto payment token for the payment method currently selected on the coordinator.
+     * Call after a successful `collectPaymentMethod(...)`.
+     *
+     * @returns Promise that resolves to an object with cryptoPaymentToken or error
+     */
+    createCryptoPaymentToken: _createCryptoPaymentToken,
+
+    /**
+     * Performs the checkout flow for a crypto onramp session, handling any required authentication steps.
+     *
+     * @param onrampSessionId The onramp session identifier
+     * @returns Promise that resolves to an object with an optional error property
+     */
+    performCheckout: _performCheckout,
+
+    /**
+     * Authorizes a Link auth intent and authenticates the user if necessary.
+     *
+     * @param linkAuthIntentId The Link auth intent ID to authorize
+     * @returns Promise that resolves to an object with status and customerId or error
+     */
+    authorize: _authorize,
+
+    /**
+     * Retrieves display data (icon, label, sublabel) for the given payment method details.
+     * Suitable for rendering in the UI to summarize the selected payment method.
+     *
+     * @param token The token containing payment method details (card or bank account) to get display data for
+     * @returns Promise that resolves to an object with displayData or error
+     */
+    getCryptoTokenDisplayData: _getCryptoTokenDisplayData,
+
+    /**
+     * Logs out the current user from their Link account.
+     *
+     * @returns Promise that resolves to an object with an optional error property
+     */
+    logOut: _logOut,
+
+    /**
+     * Determines whether an error is an authentication-related error that requires re-authentication.
+     * Useful for implementing automatic re-authentication flows when sessions expire or become invalid.
+     *
+     * @param error The error object to check, typically from onramp method calls
+     * @returns True if the error indicates an authentication issue, false otherwise
+     */
+    isAuthError: _isAuthError,
+  };
+}

package/src/index.tsx

@@ -5,6 +5,7 @@ export { useStripe } from './hooks/useStripe';
 export { usePlatformPay } from './hooks/usePlatformPay';
 export { usePaymentSheet } from './hooks/usePaymentSheet';
 export { useFinancialConnectionsSheet } from './hooks/useFinancialConnectionsSheet';
+export { useOnramp } from './hooks/useOnramp';
 
 //components
 export { initStripe, StripeProvider } from './components/StripeProvider';
@@ -34,3 +35,15 @@ export type { Props as CustomerSheetProps } from './components/CustomerSheet';
 export * from './types/EmbeddedPaymentElement';
 export * from './types/PaymentSheet';
 export * from './types/ConfirmationToken';
+
+//connect components
+export {
+  ConnectComponentsProvider,
+  loadConnectAndInitialize,
+} from './connect/ConnectComponentsProvider';
+export type {
+  StripeConnectInstance,
+  StripeConnectInitParams,
+  StripeConnectUpdateParams,
+} from './connect/connectTypes';
+export * from './connect/Components';

package/src/plugin/withStripe.ts

@@ -5,7 +5,10 @@ import {
   IOSConfig,
   withAndroidManifest,
   withEntitlementsPlist,
+  withGradleProperties,
+  withPodfile,
 } from '@expo/config-plugins';
+import path from 'path';
 
 const {
   addMetaDataItemToMainApplication,
@@ -22,6 +25,13 @@ type StripePluginProps = {
    */
   merchantIdentifier: string | string[];
   enableGooglePay: boolean;
+  /**
+   * Whether to include Onramp functionality in the build.
+   * When true, adds StripeSdk_includeOnramp=true to gradle.properties for Android
+   * and includes the Onramp pod for iOS.
+   * Defaults to false.
+   */
+  includeOnramp?: boolean;
 };
 
 const withStripe: ConfigPlugin<StripePluginProps> = (config, props) => {
@@ -33,15 +43,48 @@ const withStripe: ConfigPlugin<StripePluginProps> = (config, props) => {
 
 const withStripeIos: ConfigPlugin<StripePluginProps> = (
   expoConfig,
-  { merchantIdentifier }
+  { merchantIdentifier, includeOnramp = false }
 ) => {
-  return withEntitlementsPlist(expoConfig, (config) => {
-    config.modResults = setApplePayEntitlement(
+  let resultConfig = withEntitlementsPlist(expoConfig, (entitlementsConfig) => {
+    entitlementsConfig.modResults = setApplePayEntitlement(
       merchantIdentifier,
-      config.modResults
+      entitlementsConfig.modResults
     );
-    return config;
+    return entitlementsConfig;
   });
+
+  // Conditionally include Onramp pod for iOS.
+  if (includeOnramp) {
+    resultConfig = withPodfile(resultConfig, (config) => {
+      const podfile = config.modResults.contents;
+
+      const localPodPath = path.dirname(
+        require.resolve('@stripe/stripe-react-native/package.json', {
+          paths: [config.modRequest.projectRoot],
+        })
+      );
+      const relativePodPath = path.relative(
+        path.join(config.modRequest.projectRoot, 'ios'),
+        localPodPath
+      );
+
+      // Using Expo BuildProperties with `extraPods` unfortunately results in
+      // an empty pod, so we're modifying the Podfile directly. The pod line
+      // *must* come after the use_native_modules! call.
+      const podLine = `  pod 'stripe-react-native/Onramp', :path => '${relativePodPath}'`;
+
+      if (!podfile.includes(podLine)) {
+        config.modResults.contents = podfile.replace(
+          'config = use_native_modules!(config_command)',
+          (match) => `${match}\n${podLine}`
+        );
+      }
+
+      return config;
+    });
+  }
+
+  return resultConfig;
 };
 
 /**
@@ -94,9 +137,9 @@ export const withNoopSwiftFile: ConfigPlugin = (config) => {
 
 const withStripeAndroid: ConfigPlugin<StripePluginProps> = (
   expoConfig,
-  { enableGooglePay = false }
+  { enableGooglePay = false, includeOnramp = false }
 ) => {
-  return withAndroidManifest(expoConfig, (config) => {
+  let resultConfig = withAndroidManifest(expoConfig, (config) => {
     config.modResults = setGooglePayMetaData(
       enableGooglePay,
       config.modResults
@@ -104,6 +147,17 @@ const withStripeAndroid: ConfigPlugin<StripePluginProps> = (
 
     return config;
   });
+
+  resultConfig = withGradleProperties(resultConfig, (config) => {
+    config.modResults = setOnrampGradleProperty(
+      includeOnramp,
+      config.modResults
+    );
+
+    return config;
+  });
+
+  return resultConfig;
 };
 
 /**
@@ -138,4 +192,47 @@ export function setGooglePayMetaData(
   return modResults;
 }
 
+/**
+ * Adds or removes the StripeSdk_includeOnramp property in gradle.properties.
+ *
+ * @param includeOnramp Whether to include Onramp functionality
+ * @param modResults The current gradle.properties as PropertiesItem array
+ * @returns Modified PropertiesItem array
+ */
+export function setOnrampGradleProperty(
+  includeOnramp: boolean,
+  modResults: AndroidConfig.Properties.PropertiesItem[]
+): AndroidConfig.Properties.PropertiesItem[] {
+  const ONRAMP_PROPERTY_KEY = 'StripeSdk_includeOnramp';
+
+  // Find existing property if it exists
+  const existingPropertyIndex = modResults.findIndex(
+    (item) => item.type === 'property' && item.key === ONRAMP_PROPERTY_KEY
+  );
+
+  if (includeOnramp) {
+    // Add or update the property to true
+    const propertyItem = {
+      type: 'property' as const,
+      key: ONRAMP_PROPERTY_KEY,
+      value: 'true',
+    };
+
+    if (existingPropertyIndex >= 0) {
+      // Update existing property
+      modResults[existingPropertyIndex] = propertyItem;
+    } else {
+      // Add new property at the end
+      modResults.push(propertyItem);
+    }
+  } else {
+    // Remove the property if it exists
+    if (existingPropertyIndex >= 0) {
+      modResults.splice(existingPropertyIndex, 1);
+    }
+  }
+
+  return modResults;
+}
+
 export default createRunOncePlugin(withStripe, pkg.name, pkg.version);

package/src/specs/NativeConnectAccountOnboardingView.ts

@@ -0,0 +1,19 @@
+import type { HostComponent, ViewProps } from 'react-native';
+import type { DirectEventHandler } from 'react-native/Libraries/Types/CodegenTypes';
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+
+type OnExitActionEvent = Readonly<{}>;
+
+export interface NativeProps extends ViewProps {
+  visible: boolean;
+  title?: string;
+  backgroundColor?: string;
+  textColor?: string;
+  onExitAction: DirectEventHandler<OnExitActionEvent>;
+}
+
+type ComponentType = HostComponent<NativeProps>;
+
+export default codegenNativeComponent<NativeProps>(
+  'ConnectAccountOnboardingView'
+) as ComponentType;

package/src/specs/NativeEmbeddedPaymentElement.ts

@@ -15,10 +15,14 @@ export interface NativeCommands {
   clearPaymentOption: (
     viewRef: React.ElementRef<HostComponent<NativeProps>>
   ) => void;
+  update: (
+    viewRef: React.ElementRef<HostComponent<NativeProps>>,
+    intentConfigurationJson: string
+  ) => void;
 }
 
 export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
-  supportedCommands: ['confirm', 'clearPaymentOption'],
+  supportedCommands: ['confirm', 'clearPaymentOption', 'update'],
 });
 
 type ComponentType = HostComponent<NativeProps>;

package/src/specs/NativeNavigationBar.ts

@@ -0,0 +1,16 @@
+import type { HostComponent, ViewProps } from 'react-native';
+import type { DirectEventHandler } from 'react-native/Libraries/Types/CodegenTypes';
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+
+export type CloseButtonPressEvent = Readonly<{}>;
+
+export interface NativeProps extends ViewProps {
+  title?: string;
+  onCloseButtonPress?: DirectEventHandler<CloseButtonPressEvent>;
+}
+
+type ComponentType = HostComponent<NativeProps>;
+
+export default codegenNativeComponent<NativeProps>(
+  'NavigationBar'
+) as ComponentType;

package/src/specs/NativeOnrampSdkModule.ts

@@ -0,0 +1,47 @@
+import { TurboModuleRegistry } from 'react-native';
+import type { TurboModule } from 'react-native/Libraries/TurboModule/RCTExport';
+import type { EventEmitter } from 'react-native/Libraries/Types/CodegenTypes';
+import type { Address, InitialiseParams, Onramp } from '../types';
+import type { UnsafeObject } from './utils';
+
+export interface Spec extends TurboModule {
+  initialise(params: UnsafeObject<InitialiseParams>): Promise<void>;
+  configureOnramp(
+    config: UnsafeObject<Onramp.Configuration>
+  ): Promise<Onramp.VoidResult>;
+  hasLinkAccount(email: string): Promise<Onramp.HasLinkAccountResult>;
+  registerLinkUser(
+    info: UnsafeObject<Onramp.LinkUserInfo>
+  ): Promise<Onramp.RegisterLinkUserResult>;
+  registerWalletAddress(
+    walletAddress: string,
+    network: string
+  ): Promise<Onramp.VoidResult>;
+  attachKycInfo(
+    kycInfo: UnsafeObject<Onramp.KycInfo>
+  ): Promise<Onramp.VoidResult>;
+  presentKycInfoVerification: (
+    updatedAddress: UnsafeObject<Address> | null
+  ) => Promise<Onramp.VerifyKycResult>;
+  updatePhoneNumber(phone: string): Promise<Onramp.VoidResult>;
+  authenticateUser(): Promise<Onramp.AuthenticateUserResult>;
+  authenticateUserWithToken(
+    linkAuthTokenClientSecret: string
+  ): Promise<Onramp.VoidResult>;
+  verifyIdentity(): Promise<Onramp.VoidResult>;
+  collectPaymentMethod(
+    paymentMethod: string,
+    platformPayParams: UnsafeObject<any>
+  ): Promise<Onramp.CollectPaymentMethodResult>;
+  provideCheckoutClientSecret(clientSecret: string | null): void;
+  onCheckoutClientSecretRequested: EventEmitter<UnsafeObject<any>>;
+  createCryptoPaymentToken(): Promise<Onramp.CreateCryptoPaymentTokenResult>;
+  performCheckout(onrampSessionId: string): Promise<Onramp.VoidResult>;
+  onrampAuthorize(linkAuthIntentId: string): Promise<Onramp.AuthorizeResult>;
+  getCryptoTokenDisplayData(
+    token: UnsafeObject<Onramp.CryptoPaymentToken>
+  ): Promise<Onramp.PaymentDisplayDataResult>;
+  logout(): Promise<Onramp.VoidResult>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('OnrampSdk');

package/src/specs/NativeStripeSdkModule.ts

@@ -196,6 +196,11 @@ export interface Spec extends TurboModule {
 
   setFinancialConnectionsForceNativeFlow(enabled: boolean): Promise<void>;
 
+  openAuthenticatedWebView(
+    id: string,
+    url: string
+  ): Promise<{ url?: string } | null>;
+
   // Events
   addListener: (eventType: string) => void;
   removeListeners: (count: number) => void;

package/src/types/EmbeddedPaymentElement.tsx

@@ -550,9 +550,30 @@ export function useEmbeddedPaymentElement(
     return getElementOrThrow(elementRef).confirm();
   }, [isAndroid]);
   const update = useCallback(
-    (cfg: PaymentSheetTypes.IntentConfiguration) =>
-      getElementOrThrow(elementRef).update(cfg),
-    []
+    (cfg: PaymentSheetTypes.IntentConfiguration) => {
+      if (isAndroid) {
+        const currentRef = viewRef.current;
+        if (currentRef) {
+          return new Promise<{ status: string } | null>((resolve) => {
+            const sub = addListener(
+              'embeddedPaymentElementUpdateComplete',
+              (result: { status: string } | null) => {
+                sub.remove();
+                resolve(result);
+              }
+            );
+            Commands.update(currentRef, JSON.stringify(cfg));
+          });
+        }
+        return Promise.reject(
+          new Error('Unable to find Android embedded payment element view!')
+        );
+      }
+
+      // iOS: use native module directly
+      return getElementOrThrow(elementRef).update(cfg);
+    },
+    [isAndroid]
   );
   const clearPaymentOption = useCallback((): Promise<void> => {
     if (isAndroid) {

package/src/types/Errors.ts

@@ -44,6 +44,12 @@ export enum PaymentSheetError {
   Timeout = 'Timeout',
 }
 
+export enum OnrampError {
+  Failed = 'Failed',
+  Canceled = 'Canceled',
+  Unknown = 'Unknown',
+}
+
 export type ErrorType =
   | 'api_connection_error'
   | 'api_error'