@deuna/react-native-sdk 2.0.4 → 2.1.0-beta.1

package/src/types/base.ts

@@ -3,29 +3,105 @@ import {
   NextActionWidgetCallbacks,
   PaymentWidgetCallbacks,
   VoucherWidgetCallbacks,
-} from './interfaces/callbacks';
-import { CustomStyles } from './interfaces/customStyle';
-import { ElementWidgetType } from './helpers/urlConfig';
+} from "./interfaces/callbacks";
+
+export interface GooglePayTransactionInfo {
+  totalPrice: string;
+  totalPriceStatus: string;
+  currencyCode: string;
+  countryCode: string;
+  totalPriceLabel?: string;
+}
+
+export interface ApplePayTransactionInfo {
+  label: string;
+  amount: string;
+  currencyCode: string;
+  countryCode: string;
+}
+
+export type GooglePayTokenizationType = "PAYMENT_GATEWAY" | "DIRECT";
+
+export interface GooglePayWalletConfig {
+  merchantId: string;
+  merchantName: string;
+  /** Payment gateway identifier (e.g. 'deuna', 'adyen') — used with PAYMENT_GATEWAY tokenization */
+  gateway: string;
+  /** Merchant identifier within the payment gateway — used with PAYMENT_GATEWAY tokenization */
+  gatewayMerchantId: string;
+  /** Tokenization type: "PAYMENT_GATEWAY" (default) or "DIRECT" */
+  tokenizationType?: GooglePayTokenizationType;
+  /** Base64-encoded public key for DIRECT tokenization */
+  publicKey?: string;
+  /** Protocol version for DIRECT tokenization (defaults to "ECv2") */
+  protocolVersion?: string;
+  transactionInfo?: GooglePayTransactionInfo;
+  allowedCardNetworks?: Array<
+    "AMEX" | "DISCOVER" | "INTERAC" | "JCB" | "MASTERCARD" | "VISA"
+  >;
+  allowedCardAuthMethods?: Array<"PAN_ONLY" | "CRYPTOGRAM_3DS">;
+}
+
+export interface ApplePayWalletConfig {
+  /** Optional — under Option B (DEUNA-Managed), the backend resolves it via X-Api-Key. */
+  merchantIdentifier?: string;
+  displayName: string;
+  transactionInfo?: ApplePayTransactionInfo;
+  supportedNetworks?: string[];
+  merchantCapabilities?: string[];
+}
+
+export interface WalletElementConfig {
+  GOOGLE_PAY?: GooglePayWalletConfig;
+  APPLE_PAY?: ApplePayWalletConfig;
+}
+
+/**
+ * Parameters for `getWalletsAvailable()`.
+ *
+ * - **No arguments (Elements flow):** The SDK calls the DEUNA SSR endpoint
+ *   with just the `publicApiKey` to resolve wallet credentials from the
+ *   merchant configuration.
+ *
+ * - **`{ orderToken, userInfo }` (Elements flow with order):** Same SSR call
+ *   but includes order data so transactionInfo is pre-resolved. This avoids
+ *   a second SSR call during the click handler, which is critical for Apple Pay
+ *   (user gesture must reach `session.begin()` within ~5 seconds).
+ *
+ * - **`WalletElementConfig` (Payment Widget / Modular Checkout):**
+ *   Uses the provided credentials directly. No SSR call.
+ */
+export type GetWalletsAvailableParams =
+  | WalletElementConfig
+  | {
+      orderToken?: string;
+      userInfo?: Partial<UserInfo>;
+    };
+
+
+import { CustomStyles } from "./interfaces/customStyle";
+import { ElementWidgetType } from "./helpers/urlConfig";
 import {
   InitWidgetBase,
   PaymentMethodConfigurationFlow,
-} from './interfaces/initWidgetBase';
+  UserInfo,
+} from "./interfaces/initWidgetBase";
 import {
   Merchant,
   PaymentMethodTypes,
   PaymentProcessorName,
-} from './interfaces/merchant';
-import { Order } from './interfaces/order';
-import { User } from './interfaces/user';
-import { InitFraudProvidersProps } from './fraudProviders';
+} from "./interfaces/merchant";
+import { Order } from "./interfaces/order";
+import { User } from "./interfaces/user";
+import { InitFraudProvidersProps } from "./fraudProviders";
 
-export type Environment = 'production' | 'sandbox' | 'develop' | 'staging';
+export type Environment = "production" | "sandbox" | "develop" | "staging";
 
 export interface InitializeParams {
   environment?: Environment;
   publicApiKey: string;
 }
-export type SubmitStatus = 'success' | 'error';
+export type SubmitStatus = "success" | "error";
 
 export type SubmitResult = {
   status: SubmitStatus;
@@ -57,7 +133,7 @@ export type RefetchOrder = () => Promise<Order | null>;
 export type OrderData = { orderToken?: string; userToken?: string };
 export type SetOrderDataFn = (data: OrderData) => Promise<void>;
 
-export type InitPaymentWidgetParams = Omit<InitWidgetBase, 'callbacks'> & {
+export type InitPaymentWidgetParams = Omit<InitWidgetBase, "callbacks"> & {
   orderToken: string;
   callbacks?: PaymentWidgetCallbacks;
   paymentMethods?: {
@@ -72,17 +148,19 @@ export type InitPaymentWidgetParams = Omit<InitWidgetBase, 'callbacks'> & {
   sessionId?: string;
 };
 
-export type InitElementsWidgetParams = Omit<InitWidgetBase, 'callbacks'> & {
+export type InitElementsWidgetParams = Omit<InitWidgetBase, "callbacks"> & {
   callbacks?: ElementsWidgetCallbacks;
   types?: ElementWidgetType[];
+  /** Configuration for wallet payment providers (Google Pay, Apple Pay) */
+  walletConfig?: WalletElementConfig;
 };
 
-export type InitNextActionWidgetParams = Omit<InitWidgetBase, 'callbacks'> & {
+export type InitNextActionWidgetParams = Omit<InitWidgetBase, "callbacks"> & {
   orderToken: string;
   callbacks: NextActionWidgetCallbacks;
 };
 
-export type InitVoucherWidgetParams = Omit<InitWidgetBase, 'callbacks'> & {
+export type InitVoucherWidgetParams = Omit<InitWidgetBase, "callbacks"> & {
   orderToken: string;
   callbacks: VoucherWidgetCallbacks;
 };

package/src/types/envs.ts

@@ -42,6 +42,20 @@ export const siftCred = {
   [Env.Sandbox]: 'b267dfc8a5'
 };
 
+export const elements = {
+  [Env.Production]: 'https://elements.deuna.com',
+  [Env.Staging]: 'https://elements.stg.deuna.io',
+  [Env.Develop]: 'https://elements.dev.deuna.io',
+  [Env.Sandbox]: 'https://elements.sandbox.deuna.io',
+};
+
+export const api = {
+  [Env.Production]: 'https://api.deuna.io',
+  [Env.Staging]: 'https://api.stg.deuna.io',
+  [Env.Develop]: 'https://api.dev.deuna.io',
+  [Env.Sandbox]: 'https://api.sandbox.deuna.io',
+};
+
 export const proxyUrls = {
   URL: 'mimos.vendodeuna.com',
   FPJS_BEHAVIOR_PATH: 'thomas',

package/src/types/helpers/urlConfig.ts

@@ -81,4 +81,4 @@ export interface ElementWidgetType {
   name: ElementWidgetTypeName;
 }
 
-type ElementWidgetTypeName = "vault" | "click_to_pay";
+type ElementWidgetTypeName = "vault" | "click_to_pay" | "GOOGLE_PAY" | "APPLE_PAY";

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>;
+}