@oobit/react-native-sdk 1.0.0

package/src/types.ts

@@ -0,0 +1,179 @@
+/**
+ * Widget SDK Types
+ * Messages that can be sent between the web widget and React Native
+ */
+
+/**
+ * Token information for transaction confirmation
+ * Minimal fields needed to display a send transaction confirmation page
+ */
+export interface DepositToken {
+  symbol: string;
+  name: string;
+  iconUrl: string | null;
+  networkName: string;
+}
+
+export type WidgetMessageType =
+  | 'widget:ready'
+  | 'widget:open-wallet'
+  | 'widget:card-created'
+  | 'widget:error'
+  | 'widget:close'
+  | 'widget:transaction-requested'
+  | 'widget:token-expired';
+
+/**
+ * Native Message Types
+ * Messages sent from the native app to the web widget
+ */
+export type NativeMessageType =
+  | 'native:platform-info'
+  | 'native:wallet-opened'
+  | 'native:back-pressed'
+  | 'native:navigate-back';
+
+export interface NativeBackPressedMessage {
+  type: 'native:back-pressed';
+  timestamp: number;
+}
+
+export interface NativeNavigateBackMessage {
+  type: 'native:navigate-back';
+  timestamp: number;
+}
+
+export interface NativePlatformInfoMessage {
+  type: 'native:platform-info';
+  payload: {
+    platform: string;
+    walletAvailable: boolean;
+  };
+}
+
+export interface NativeWalletOpenedMessage {
+  type: 'native:wallet-opened';
+  payload: {
+    success: boolean;
+  };
+}
+
+export type NativeMessage =
+  | NativeBackPressedMessage
+  | NativeNavigateBackMessage
+  | NativePlatformInfoMessage
+  | NativeWalletOpenedMessage;
+
+export interface BaseWidgetMessage {
+  type: WidgetMessageType;
+  timestamp: number;
+}
+
+export interface WidgetReadyMessage extends BaseWidgetMessage {
+  type: 'widget:ready';
+}
+
+export interface OpenWalletMessage extends BaseWidgetMessage {
+  type: 'widget:open-wallet';
+  payload: {
+    platform: 'ios' | 'android';
+  };
+}
+
+export interface CardCreatedMessage extends BaseWidgetMessage {
+  type: 'widget:card-created';
+  payload: {
+    cardId: string;
+    cardType: 'virtual' | 'physical';
+    last4: string;
+  };
+}
+
+export interface WidgetErrorMessage extends BaseWidgetMessage {
+  type: 'widget:error';
+  payload: {
+    code: string;
+    message: string;
+  };
+}
+
+export interface WidgetCloseMessage extends BaseWidgetMessage {
+  type: 'widget:close';
+}
+
+export interface TransactionRequestedMessage extends BaseWidgetMessage {
+  type: 'widget:transaction-requested';
+  payload: {
+    token: DepositToken;
+    cryptoAmount: string;
+    depositAddress: string;
+    depositAddressTag: string | null;
+  };
+}
+
+export interface TokenExpiredMessage extends BaseWidgetMessage {
+  type: 'widget:token-expired';
+  payload?: {
+    reason?: string;
+  };
+}
+
+export type WidgetMessage =
+  | WidgetReadyMessage
+  | OpenWalletMessage
+  | CardCreatedMessage
+  | WidgetErrorMessage
+  | WidgetCloseMessage
+  | TransactionRequestedMessage
+  | TokenExpiredMessage;
+
+/**
+ * SDK Configuration
+ */
+export interface WidgetSDKConfig {
+  accessToken: string; // Required: Access token from backend
+  userWalletAddress: string; // Required: User's external wallet address for crypto deposits
+  onReady?: () => void;
+  onCardCreated?: (cardId: string, cardType: string, last4: string) => void;
+  onError?: (code: string, message: string) => void;
+  onClose?: () => void;
+  onTransactionRequested?: (token: DepositToken, cryptoAmount: string, depositAddress: string, depositAddressTag: string | null) => void;
+}
+
+/**
+ * Platform-specific wallet URLs
+ */
+export const WALLET_URLS = {
+  ios: {
+    passkit: 'shoebox://', // Apple Wallet deep link
+    fallback: 'https://wallet.apple.com',
+  },
+  android: {
+    googlePay: 'https://pay.google.com/gp/w/home/wallet',
+    fallback: 'https://wallet.google.com',
+  },
+} as const;
+
+/**
+ * Message type constants that clients can use
+ * @example
+ * if (message.type === MessageTypes.READY) {
+ *   // Handle ready
+ * }
+ */
+export const MessageTypes = {
+  // Widget → Native
+  READY: 'widget:ready',
+  OPEN_WALLET: 'widget:open-wallet',
+  CARD_CREATED: 'widget:card-created',
+  ERROR: 'widget:error',
+  CLOSE: 'widget:close',
+  TRANSACTION_REQUESTED: 'widget:transaction-requested',
+  TOKEN_EXPIRED: 'widget:token-expired',
+  // Native → Widget
+  PLATFORM_INFO: 'native:platform-info',
+  WALLET_OPENED: 'native:wallet-opened',
+  BACK_PRESSED: 'native:back-pressed',
+  NAVIGATE_BACK: 'native:navigate-back',
+} as const;
+

package/src/walletUtils.ts

@@ -0,0 +1,170 @@
+/**
+ * Wallet Integration Utilities
+ * Handles opening Apple Wallet (iOS) and Google Wallet (Android)
+ */
+
+import * as IntentLauncher from "expo-intent-launcher";
+import { Alert, Linking, Platform } from "react-native";
+import { WALLET_URLS } from "./types";
+
+/**
+ * Opens the native wallet app based on platform
+ * @returns Promise that resolves when wallet opens successfully
+ */
+export const openNativeWallet = async (): Promise<boolean> => {
+  try {
+    if (Platform.OS === "ios") {
+      return await openAppleWallet();
+    } else if (Platform.OS === "android") {
+      return await openGoogleWallet();
+    } else {
+      console.warn("Wallet opening not supported on this platform");
+      return false;
+    }
+  } catch (error) {
+    console.error("Failed to open wallet:", error);
+    Alert.alert(
+      "Error",
+      "Could not open wallet. Please check if the app is installed."
+    );
+    return false;
+  }
+};
+
+/**
+ * Opens Apple Wallet on iOS
+ * Uses multiple URL schemes in order of reliability
+ */
+const openAppleWallet = async (): Promise<boolean> => {
+  const { passkit, fallback } = WALLET_URLS.ios;
+
+  try {
+    console.log("Attempting to open Apple Wallet...");
+
+    // Method 1: Try wallet:// scheme (documented as working in recent iOS)
+    try {
+      const canOpenWallet = await Linking.canOpenURL("wallet://");
+      if (canOpenWallet) {
+        await Linking.openURL("wallet://");
+        console.log("Successfully opened Apple Wallet via wallet:// scheme");
+        return true;
+      }
+    } catch (walletError) {
+      console.log("wallet:// scheme failed, trying shoebox://:", walletError);
+    }
+
+    // Method 2: Try shoebox:// scheme (undocumented but widely used)
+    // Note: This is unofficial and could potentially cause App Store rejection
+    try {
+      const canOpenShoebox = await Linking.canOpenURL(passkit);
+      if (canOpenShoebox) {
+        await Linking.openURL(passkit);
+        console.log("Successfully opened Apple Wallet via shoebox:// scheme");
+        return true;
+      }
+    } catch (shoeboxError) {
+      console.log("shoebox:// scheme failed:", shoeboxError);
+    }
+
+    // Method 3: Fallback to wallet.apple.com (opens in browser)
+    console.log("Direct schemes failed, falling back to web URL");
+    const canOpenFallback = await Linking.canOpenURL(fallback);
+    if (canOpenFallback) {
+      await Linking.openURL(fallback);
+      console.log("Opened wallet.apple.com in browser");
+      return true;
+    }
+
+    throw new Error("Apple Wallet not available");
+  } catch (error) {
+    console.error("Failed to open Apple Wallet:", error);
+    throw error;
+  }
+};
+
+/**
+ * Opens Google Wallet on Android
+ * Matches the proven Android native implementation from LinksUtils.kt
+ */
+const openGoogleWallet = async (): Promise<boolean> => {
+  const GOOGLE_WALLET_PACKAGE = "com.google.android.apps.walletnfcrel";
+
+  try {
+    console.log("Attempting to open Google Wallet...");
+
+    // First, try using the market:// scheme to just launch the app if it's installed
+    // This is the most reliable way to open an installed app without knowing the exact activity
+    try {
+      const canOpen = await Linking.canOpenURL(`market://launch?id=${GOOGLE_WALLET_PACKAGE}`);
+      console.log("Can open market launch URL:", canOpen);
+
+      if (canOpen) {
+        await Linking.openURL(`market://launch?id=${GOOGLE_WALLET_PACKAGE}`);
+        console.log("Successfully opened Google Wallet via market:// scheme");
+        return true;
+      }
+    } catch (marketLaunchError) {
+      console.log("Market launch failed, trying intent launcher:", marketLaunchError);
+    }
+
+    // Fallback: Try intent launcher with ACTION_VIEW (no explicit className)
+    // This should open the app if it handles the VIEW action
+    try {
+      await IntentLauncher.startActivityAsync("android.intent.action.VIEW", {
+        packageName: GOOGLE_WALLET_PACKAGE,
+        flags: 268435456, // FLAG_ACTIVITY_NEW_TASK (0x10000000)
+      });
+      console.log("Successfully opened Google Wallet with VIEW intent");
+      return true;
+    } catch (intentError) {
+      console.log("Intent launcher failed:", intentError);
+
+      // App is not installed, open Play Store
+      console.log("App appears to not be installed, opening Play Store");
+      try {
+        // Try native Play Store app first
+        const playStoreUrl = `market://details?id=${GOOGLE_WALLET_PACKAGE}`;
+        await Linking.openURL(playStoreUrl);
+
+        Alert.alert(
+          "Google Wallet",
+          "Google Wallet is not installed. Opening Play Store to install the app."
+        );
+        return false;
+      } catch (marketError) {
+        console.log("Market URL failed, trying web Play Store:", marketError);
+
+        // Fallback to web Play Store
+        await Linking.openURL(
+          `https://play.google.com/store/apps/details?id=${GOOGLE_WALLET_PACKAGE}`
+        );
+
+        Alert.alert(
+          "Google Wallet",
+          "Google Wallet is not installed. Opening Play Store to install the app."
+        );
+        return false;
+      }
+    }
+  } catch (error) {
+    console.error("Failed to open Google Wallet:", error);
+    throw error;
+  }
+};
+
+/**
+ * Check if wallet is available on the current platform
+ */
+export const isWalletAvailable = async (): Promise<boolean> => {
+  try {
+    if (Platform.OS === "ios") {
+      return await Linking.canOpenURL(WALLET_URLS.ios.passkit);
+    } else if (Platform.OS === "android") {
+      return await Linking.canOpenURL(WALLET_URLS.android.googlePay);
+    }
+    return false;
+  } catch (error) {
+    console.error("Error checking wallet availability:", error);
+    return false;
+  }
+};