@deuna/react-native-sdk 2.0.5 → 2.1.0-beta.2

package/src/types/interfaces/callbacks.ts

@@ -2,6 +2,20 @@ export type ClosedAction = "userAction" | "systemAction";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type Json = Record<string, any>;
 
+export interface WalletPaymentData {
+  provider: "GOOGLE_PAY" | "APPLE_PAY";
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  paymentMethodData: Record<string, any>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  shippingAddress?: Record<string, any>;
+  email?: string;
+}
+
+export interface WalletPaymentAuthResult {
+  status: "SUCCESS" | "ERROR";
+  error?: string;
+}
+
 export interface OnError {
   type: string;
   metadata: {
@@ -36,6 +50,7 @@ export interface PaymentWidgetCallbacks extends BaseCallbacks {
   onCardBinDetected?: (data: OnCardBinDetected) => void;
   onInstallmentSelected?: (data: OnInstallmentSelectedPayload) => void;
   onPaymentProcessing?: () => void;
+  onPaymentAuthorized?: (data: WalletPaymentData) => Promise<WalletPaymentAuthResult>;
 }
 
 export interface ElementsWidgetCallbacks extends BaseCallbacks {

package/src/types/interfaces/initWidgetBase.ts

@@ -11,9 +11,9 @@ type DeepPartial<T> = {
 
 export type Language = "es" | "pt" | "en";
 
-interface UserInfo {
-  firstName: string;
-  lastName: string;
+export interface UserInfo {
+  firstName?: string;
+  lastName?: string;
   email: string;
 }
 

package/src/wallets/WalletModule.ts

@@ -0,0 +1,255 @@
+import type { EventSubscription as Subscription } from 'expo-modules-core';
+import type {
+  InitElementsParams,
+  WalletProvider,
+  WalletsError,
+} from './types';
+import type { UserInfo } from '../types/interfaces/initWidgetBase';
+import type {
+  GetWalletsAvailableParams,
+  WalletElementConfig,
+} from '../types/base';
+import { fetchVaultResult } from './vaultApi';
+import { api as API_URLS } from '../types/envs';
+import { buildTokenizeBody } from './tokenize';
+
+// Lazy-load expo-modules-core so the SDK still works on environments without it.
+function getNativeWallets() {
+  try {
+    const { requireNativeModule } = require('expo-modules-core');
+    return requireNativeModule('DeunaWallets');
+  } catch {
+    return null;
+  }
+}
+
+function getEmitter() {
+  try {
+    const { EventEmitter } = require('expo-modules-core');
+    const mod = getNativeWallets();
+    return mod ? new EventEmitter(mod) : null;
+  } catch {
+    return null;
+  }
+}
+
+function isWalletElementConfig(params: GetWalletsAvailableParams): params is WalletElementConfig {
+  return 'GOOGLE_PAY' in params || 'APPLE_PAY' in params;
+}
+
+const WALLET_PROVIDER_MAP: Record<string, WalletProvider> = {
+  GOOGLE_PAY: 'google_pay',
+  APPLE_PAY: 'apple_pay',
+};
+
+/**
+ * Returns the list of wallet providers available on the current device for the given order.
+ *
+ * Two flows:
+ *  - WalletElementConfig: credentials provided directly, no vault fetch.
+ *    Native module checks device availability only.
+ *  - { orderToken?, userInfo? }: fetches vault API to get providers + credentials,
+ *    then native module filters by device availability.
+ */
+export async function getWalletsAvailable(
+  publicApiKey: string,
+  environment: string,
+  params: GetWalletsAvailableParams
+): Promise<WalletProvider[]> {
+  const mod = getNativeWallets();
+  if (!mod) {
+    console.log('❌ [Wallets] No native module available');
+    return [];
+  }
+
+  if (isWalletElementConfig(params)) {
+    const providers = Object.keys(params).filter(
+      (k): k is keyof WalletElementConfig => k === 'GOOGLE_PAY' || k === 'APPLE_PAY'
+    );
+    console.log('[Wallets] WalletElementConfig flow — providers:', providers);
+
+    const available: string[] = await mod.checkAvailableProviders({
+      providers: providers.map((p) => WALLET_PROVIDER_MAP[p]),
+      environment,
+    });
+    console.log('[Wallets] checkAvailableProviders result:', available);
+
+    return available as WalletProvider[];
+  }
+
+  const { orderToken, userInfo } = params as { orderToken?: string; userInfo?: Partial<UserInfo> };
+  console.log('[Wallets] vault flow — orderToken:', orderToken, 'environment:', environment);
+
+  const vaultResult = await fetchVaultResult(environment, publicApiKey, orderToken, userInfo);
+  console.log('[Wallets] vault result — providers:', vaultResult.providers, 'hasUserToken:', !!vaultResult.userToken);
+
+  if (vaultResult.providers.length === 0) {
+    console.log('❌ [Wallets] No providers from vault API');
+    return [];
+  }
+
+  const available: string[] = await mod.checkAvailableProviders({
+    providers: vaultResult.providers,
+    environment,
+  });
+  console.log('[Wallets] checkAvailableProviders result:', available);
+
+  return available as WalletProvider[];
+}
+
+/**
+ * Launches the native wallet payment sheet for the given provider.
+ * - Resolves with `undefined` on payment success (tokenization complete if userToken present).
+ * - Resolves with `"closed"` when the user dismisses without paying.
+ * - Rejects with a `WalletsError` on failure.
+ *
+ * Credentials are re-used from a prior getWalletsAvailable call if available,
+ * otherwise the vault API is refetched.
+ */
+export async function initElements(
+  params: InitElementsParams,
+  walletConfig?: WalletElementConfig
+): Promise<Record<string, unknown> | 'closed'> {
+  const mod = getNativeWallets();
+  if (!mod)
+    throw new Error(
+      'DeunaWallets native module is not available on this platform. ' +
+        'Ensure expo-modules-core is installed and the native module is linked.'
+    );
+
+  const { orderToken, publicApiKey, environment, walletProvider, userInfo } = params;
+
+  let credentials: Record<string, unknown> | undefined;
+  let userToken: string | undefined;
+  let userId: string | undefined;
+
+  if (walletConfig) {
+    const configKey = walletProvider === 'apple_pay' ? 'APPLE_PAY' : 'GOOGLE_PAY';
+    credentials = walletConfig[configKey] as Record<string, unknown> | undefined;
+  }
+
+  if (!credentials) {
+    console.log('[Wallets] initElements vault fetch — orderToken:', orderToken, 'hasUserInfo:', !!userInfo, 'email:', (userInfo as any)?.email);
+    const vaultResult = await fetchVaultResult(environment, publicApiKey, orderToken, userInfo);
+    console.log('[Wallets] initElements vault result — hasUserToken:', !!vaultResult.userToken, 'hasUserId:', !!vaultResult.userId, 'providers:', vaultResult.providers);
+    credentials = vaultResult.credentials[walletProvider] as Record<string, unknown> | undefined;
+    userToken = vaultResult.userToken;
+    userId = vaultResult.userId;
+  }
+
+  if (!credentials) {
+    throw {
+      code: 'WALLET_UNAVAILABLE',
+      message: `No credentials for ${walletProvider}`,
+    };
+  }
+
+  if (!userToken || !userId) {
+    throw { code: 'MISSING_USER_AUTH', message: 'userToken or userId is missing — cannot tokenize wallet payment.' };
+  }
+
+  console.log('[Wallets] launchWallet →', walletProvider, 'credentials keys:', Object.keys(credentials));
+
+  let result: Record<string, unknown> | 'closed';
+  try {
+    result = await mod.launchWallet({
+      provider: walletProvider,
+      credentials,
+      environment,
+    });
+  } catch (nativeErr: any) {
+    console.log('❌ [Wallets] launchWallet native error:', nativeErr?.message ?? JSON.stringify(nativeErr));
+    throw nativeErr;
+  }
+
+  if (result === 'closed') return 'closed';
+
+  console.log('[Wallets] launchWallet raw result:', JSON.stringify(result, null, 2));
+
+  return await tokenizeCard({
+    environment,
+    publicApiKey,
+    userId,
+    userToken,
+    provider: walletProvider,
+    paymentData: (result as Record<string, unknown>).paymentData,
+  });
+}
+
+async function tokenizeCard(params: {
+  environment: string;
+  publicApiKey: string;
+  userId: string;
+  userToken: string;
+  provider: WalletProvider;
+  paymentData: unknown;
+}): Promise<Record<string, unknown>> {
+  const { environment, publicApiKey, userId, userToken, provider, paymentData } = params;
+  const base = API_URLS[environment as keyof typeof API_URLS] ?? API_URLS.develop;
+  const url = `${base}/users/${encodeURIComponent(userId)}/cards`;
+
+  const body = buildTokenizeBody(provider, paymentData);
+
+  console.log(`[Wallets] tokenizeCard → POST ${url} provider=${provider}`);
+  console.log('[Wallets] tokenizeCard body:', JSON.stringify(body, null, 2));
+
+  let response: Response;
+  try {
+    response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${userToken}`,
+        'x-api-key': publicApiKey,
+      },
+      body: JSON.stringify(body),
+    });
+  } catch (networkErr: any) {
+    console.log(`❌ [Wallets] tokenizeCard network error: ${networkErr?.message ?? networkErr}`);
+    throw { code: 'NETWORK_ERROR', message: networkErr?.message ?? 'Network request failed' };
+  }
+
+  const responseText = await response.text().catch(() => '');
+  console.log(`[Wallets] tokenizeCard response: status=${response.status} body=${responseText}`);
+
+  let json: Record<string, unknown> = {};
+  try { json = JSON.parse(responseText); } catch { /* non-JSON body */ }
+
+  if (json?.error) {
+    const errPayload = json.error as Record<string, unknown>;
+    console.log(`❌ [Wallets] tokenizeCard API error: code=${errPayload.code} message=${errPayload.message}`);
+    throw {
+      code: errPayload.code ?? 'TOKENIZATION_ERROR',
+      message: errPayload.message ?? 'Card tokenization returned an error.',
+    };
+  }
+
+  if (!response.ok) {
+    console.log(`❌ [Wallets] tokenizeCard failed: HTTP ${response.status}`);
+    throw { code: 'TOKENIZATION_ERROR', message: `Tokenization failed: ${response.status}` };
+  }
+
+  console.log(`✅ [Wallets] tokenizeCard success`);
+  return json;
+}
+
+export function addWalletSuccessListener(
+  listener: (data: Record<string, unknown>) => void
+): Subscription | null {
+  const emitter = getEmitter();
+  return emitter?.addListener('onWalletSuccess', listener) ?? null;
+}
+
+export function addWalletErrorListener(
+  listener: (error: WalletsError) => void
+): Subscription | null {
+  const emitter = getEmitter();
+  return emitter?.addListener('onWalletError', listener) ?? null;
+}
+
+export function addWalletClosedListener(
+  listener: (payload: { action: 'userAction' | 'systemAction' }) => void
+): Subscription | null {
+  const emitter = getEmitter();
+  return emitter?.addListener('onWalletClosed', listener) ?? null;
+}

package/src/wallets/index.ts

@@ -0,0 +1,13 @@
+export {
+  getWalletsAvailable,
+  initElements,
+  addWalletSuccessListener,
+  addWalletErrorListener,
+  addWalletClosedListener,
+} from './WalletModule';
+
+export type {
+  WalletProvider,
+  WalletsError,
+  InitElementsParams,
+} from './types';

package/src/wallets/tokenize/applePay.ts

@@ -0,0 +1,22 @@
+export function buildApplePayTokenizeBody(paymentData: unknown): Record<string, unknown> {
+  const pd = (paymentData ?? {}) as Record<string, unknown>;
+  const header = (pd['header'] ?? {}) as Record<string, unknown>;
+
+  return {
+    credential_source: 'apple_pay',
+    credential_source_config: {
+      type: 'apple_pay',
+      values: {
+        system: pd['version'] ?? '',
+        merchant_transaction_id: header['transactionId'] ?? '',
+        encrypted_data: pd['data'] ?? '',
+        encryption_header: {
+          signature: pd['signature'] ?? '',
+          public_key_hash: header['publicKeyHash'] ?? '',
+          ephemeral_public_key: header['ephemeralPublicKey'] ?? '',
+        },
+        src_cx_flow_id: 'mobile',
+      },
+    },
+  };
+}

package/src/wallets/tokenize/googlePay.ts

@@ -0,0 +1,27 @@
+export function buildGooglePayTokenizeBody(paymentData: unknown): Record<string, unknown> {
+  const pd = (paymentData ?? {}) as Record<string, unknown>;
+
+  const rawPMD = pd['paymentMethodData'];
+  console.log(`[Wallets] paymentMethodData type=${typeof rawPMD} value=${JSON.stringify(rawPMD)}`);
+
+  const paymentMethodData = (rawPMD ?? {}) as Record<string, unknown>;
+
+  const rawTD = paymentMethodData['tokenizationData'];
+  console.log(`[Wallets] tokenizationData type=${typeof rawTD} value=${JSON.stringify(rawTD)}`);
+
+  const tokenizationData = (rawTD ?? {}) as Record<string, unknown>;
+  const encryptedData = (tokenizationData['token'] ?? '') as string;
+
+  console.log(`[Wallets] token type=${typeof tokenizationData['token']} length=${encryptedData.length}`);
+
+  return {
+    credential_source: 'google_pay',
+    credential_source_config: {
+      type: 'google_pay',
+      values: {
+        encrypted_data: encryptedData,
+        src_cx_flow_id: 'mobile',
+      },
+    },
+  };
+}

package/src/wallets/tokenize/index.ts

@@ -0,0 +1,12 @@
+import type { WalletProvider } from '../types';
+import { buildGooglePayTokenizeBody } from './googlePay';
+import { buildApplePayTokenizeBody } from './applePay';
+
+const tokenizeBodyBuilders: Record<WalletProvider, (paymentData: unknown) => Record<string, unknown>> = {
+  google_pay: buildGooglePayTokenizeBody,
+  apple_pay: buildApplePayTokenizeBody,
+};
+
+export function buildTokenizeBody(provider: WalletProvider, paymentData: unknown): Record<string, unknown> {
+  return tokenizeBodyBuilders[provider](paymentData);
+}

package/src/wallets/types.ts

@@ -0,0 +1,17 @@
+import type { Environment } from '../types/base';
+import type { UserInfo } from '../types/interfaces/initWidgetBase';
+
+export type WalletProvider = 'apple_pay' | 'google_pay';
+
+export interface WalletsError {
+  code: string;
+  message: string;
+}
+
+export interface InitElementsParams {
+  orderToken: string;
+  publicApiKey: string;
+  environment: Environment;
+  walletProvider: WalletProvider;
+  userInfo?: Partial<UserInfo>;
+}

package/src/wallets/vaultApi.ts

@@ -0,0 +1,229 @@
+import { ELEMENTS_URLS } from '../types/helpers/buildElementsLink';
+import type { UserInfo } from '../types/interfaces/initWidgetBase';
+
+const DEFAULT_CARD_NETWORKS = ['VISA', 'MASTERCARD', 'AMEX', 'DISCOVER'];
+const DEFAULT_AUTH_METHODS_APPLE = ['CRYPTOGRAM_3DS'];
+const DEFAULT_AUTH_METHODS_GOOGLE = ['PAN_ONLY', 'CRYPTOGRAM_3DS'];
+
+export interface ApplePayCredentials {
+  merchantIdentifier: string;
+  displayName: string;
+  supportedNetworks: string[];
+  merchantCapabilities: string[];
+  transactionInfo?: {
+    amount: string;
+    currencyCode: string;
+    countryCode: string;
+    label: string;
+  };
+  credentialId?: string;
+}
+
+export interface GooglePayCredentials {
+  merchantId: string;
+  merchantName: string;
+  gateway: string;
+  gatewayMerchantId: string;
+  tokenizationType: 'PAYMENT_GATEWAY' | 'DIRECT';
+  publicKey?: string;
+  allowedCardNetworks: string[];
+  allowedAuthMethods: string[];
+  transactionInfo?: {
+    totalPrice: string;
+    currencyCode: string;
+    countryCode: string;
+  };
+}
+
+export type WalletCredentials = ApplePayCredentials | GooglePayCredentials;
+
+export interface VaultFetchResult {
+  providers: string[];
+  credentials: Record<string, WalletCredentials>;
+  userToken?: string;
+  userId?: string;
+}
+
+export async function fetchVaultResult(
+  environment: string,
+  publicApiKey: string,
+  orderToken?: string,
+  userInfo?: Partial<UserInfo>
+): Promise<VaultFetchResult> {
+  const base =
+    ELEMENTS_URLS[environment as keyof typeof ELEMENTS_URLS] ??
+    ELEMENTS_URLS.develop;
+  const url = orderToken
+    ? `${base}/api/vault?orderToken=${encodeURIComponent(orderToken)}`
+    : `${base}/api/vault`;
+
+  const body = userInfo ? buildUserInfoBody(userInfo) : undefined;
+  console.log(
+    '[Wallets] fetchVaultResult — url:',
+    url,
+    'body:',
+    JSON.stringify(body)
+  );
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: { 'x-api-key': publicApiKey, 'Content-Type': 'application/json' },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+
+  if (!response.ok) {
+    console.error('[Wallets] Vault API error:', response.status);
+    console.error('[Wallets] Vault API error message:', response.statusText);
+    console.error('[Wallets] Vault API error response:', response);
+    throw {
+      code: 'VAULT_FETCH_FAILED',
+      message: `Vault API error: ${response.status}`,
+    };
+  }
+
+  return parseVaultResponse(await response.json());
+}
+
+function parseVaultResponse(json: Record<string, unknown>): VaultFetchResult {
+  console.log(
+    '[Wallets] parseVaultResponse result:',
+    JSON.stringify(json, null, 2)
+  );
+  const paymentMethods = (json['paymentMethods'] as unknown[]) ?? [];
+  const checkout = json['checkout'] as Record<string, unknown> | undefined;
+  const merchant = checkout?.['merchant'] as
+    | Record<string, unknown>
+    | undefined;
+  const order = (checkout?.['order'] as Record<string, unknown> | undefined)?.[
+    'order'
+  ] as Record<string, unknown> | undefined;
+  const userAuthData = (
+    json['userAuthResponse'] as Record<string, unknown> | undefined
+  )?.['data'] as Record<string, unknown> | undefined;
+
+  const credentialParser = {
+    apple_pay: parseApplePayCredentials,
+    google_pay: parseGooglePayCredentials,
+  };
+
+  const providers: string[] = [];
+  const credentials: Record<string, WalletCredentials> = {};
+
+  for (const rawMethod of paymentMethods) {
+    const method = rawMethod as Record<string, unknown>;
+    const processorName = method['processor_name'] as string | undefined;
+    if (!processorName || providers.includes(processorName)) continue;
+
+    providers.push(processorName);
+
+    const parse =
+      credentialParser[processorName as keyof typeof credentialParser];
+    if (parse) {
+      credentials[processorName] = parse(method, merchant, order);
+    }
+  }
+
+  return {
+    providers,
+    credentials,
+    userToken:
+      (userAuthData?.['user_token'] as string | undefined) || undefined,
+    userId: (userAuthData?.['user_id'] as string | undefined) || undefined,
+  };
+}
+
+function parseApplePayCredentials(
+  method: Record<string, unknown>,
+  merchant: Record<string, unknown> | undefined,
+  order: Record<string, unknown> | undefined
+): ApplePayCredentials {
+  const extra = (method['extra_params'] as Record<string, unknown>) ?? {};
+  const displayName =
+    (extra['merchant_name'] as string | undefined) ??
+    (merchant?.['name'] as string | undefined) ??
+    '';
+
+  return {
+    merchantIdentifier:
+      (extra['mobile_merchant_id'] as string | undefined) ?? '',
+    displayName,
+    supportedNetworks:
+      (extra['allowed_card_networks'] as string[] | undefined) ??
+      DEFAULT_CARD_NETWORKS,
+    merchantCapabilities:
+      (extra['allowed_auth_methods'] as string[] | undefined) ??
+      DEFAULT_AUTH_METHODS_APPLE,
+    transactionInfo: buildApplePayTransactionInfo(order, merchant, displayName),
+    credentialId: (method['id'] as string | undefined) || undefined,
+  };
+}
+
+function buildApplePayTransactionInfo(
+  order: Record<string, unknown> | undefined,
+  merchant: Record<string, unknown> | undefined,
+  label: string
+): ApplePayCredentials['transactionInfo'] {
+  const currency = order?.['currency'] as string | undefined;
+  const country = merchant?.['country'] as string | undefined;
+  if (!currency || !country) return undefined;
+  const totalCents = (order?.['total_amount'] as number | undefined) ?? 0;
+  return {
+    amount: (totalCents / 100).toFixed(2),
+    currencyCode: currency.toUpperCase(),
+    countryCode: country.toUpperCase(),
+    label,
+  };
+}
+
+function parseGooglePayCredentials(
+  method: Record<string, unknown>,
+  merchant: Record<string, unknown> | undefined,
+  order: Record<string, unknown> | undefined
+): GooglePayCredentials {
+  const creds = (method['credentials'] as Record<string, unknown>) ?? {};
+  const extra = (method['extra_params'] as Record<string, unknown>) ?? {};
+  const gateway = (extra['gateway'] as string | undefined) ?? '';
+
+  return {
+    merchantId: (extra['mobile_merchant_id'] as string | undefined) ?? '',
+    merchantName: (merchant?.['name'] as string | undefined) ?? '',
+    gateway,
+    gatewayMerchantId:
+      (extra['mobile_merchant_id'] as string | undefined) ?? '',
+    tokenizationType:
+      gateway.toUpperCase() === 'DIRECT' ? 'DIRECT' : 'PAYMENT_GATEWAY',
+    publicKey: (creds['public_api_key'] as string | undefined) || undefined,
+    allowedCardNetworks:
+      (extra['allowed_card_networks'] as string[] | undefined) ??
+      DEFAULT_CARD_NETWORKS,
+    allowedAuthMethods:
+      (extra['allowed_auth_methods'] as string[] | undefined) ??
+      DEFAULT_AUTH_METHODS_GOOGLE,
+    transactionInfo: buildGooglePayTransactionInfo(order, merchant),
+  };
+}
+
+function buildGooglePayTransactionInfo(
+  order: Record<string, unknown> | undefined,
+  merchant: Record<string, unknown> | undefined
+): GooglePayCredentials['transactionInfo'] {
+  const currency = order?.['currency'] as string | undefined;
+  const country = merchant?.['country'] as string | undefined;
+  if (!currency || !country) return undefined;
+  const totalCents = (order?.['total_amount'] as number | undefined) ?? 0;
+  return {
+    totalPrice: (totalCents / 100).toFixed(2),
+    currencyCode: currency.toUpperCase(),
+    countryCode: country.toUpperCase(),
+  };
+}
+
+function buildUserInfoBody(
+  userInfo: Partial<UserInfo>
+): Record<string, unknown> | undefined {
+  if (!userInfo.email) return undefined;
+  const body: Record<string, unknown> = { email: userInfo.email };
+  if (userInfo.firstName) body['firstName'] = userInfo.firstName;
+  if (userInfo.lastName) body['lastName'] = userInfo.lastName;
+  return body;
+}