framepayments-react-native 3.0.1 → 4.0.0

package/lib/applePay.js

@@ -0,0 +1,235 @@
+import { NativeModules, Platform } from 'react-native';
+import { client } from './client';
+import { ErrorCodes, frameError } from './errors';
+import { ensureAttested, generateAssertionForPayment } from './attestation';
+import { getApplePayMerchantId } from './config';
+const LINKING_ERROR = "The native module 'FrameApplePay' isn't linked. Run `pod install` and rebuild the app.";
+const FrameApplePay = NativeModules.FrameApplePay
+    ? NativeModules.FrameApplePay
+    : new Proxy({}, {
+        get() {
+            throw new Error(LINKING_ERROR);
+        },
+    });
+// Apple's standard set of supported networks for in-app payment requests. Mirrors
+// `ApplePayPresenter.swift` in the legacy Frame iOS bridge.
+const DEFAULT_SUPPORTED_NETWORKS = ['visa', 'masterCard', 'amex', 'discover', 'JCB'];
+export async function canMakeApplePay() {
+    if (Platform.OS !== 'ios')
+        return false;
+    return FrameApplePay.canMakeApplePay();
+}
+/**
+ * Apple Pay token-out flow.
+ *   1. Ensure the device is attested (App Attest).
+ *   2. Present the PKPaymentAuthorizationController sheet via the bridge.
+ *   3. Generate a device assertion bound to the payment token.
+ *   4. Create the Apple Pay payment method via frame-node (publishable key).
+ *   5. Create a ChargeIntent (customer owner) or Transfer (account owner).
+ *   6. Settle the still-open Apple Pay sheet — success on success, failure on
+ *      any exception — so the spinner-stays-up UX matches the native flow.
+ */
+export async function presentApplePayFlow(options) {
+    if (Platform.OS !== 'ios') {
+        throw frameError(ErrorCodes.PLATFORM_UNSUPPORTED, 'Frame.presentApplePay is iOS-only; use presentGooglePay on Android.');
+    }
+    validateOwner(options.owner);
+    const merchantId = getApplePayMerchantId();
+    if (!merchantId) {
+        throw frameError(ErrorCodes.INVALID_MERCHANT_ID, 'No Apple Pay merchant ID configured. Pass `applePayMerchantId` to Frame.initialize(...).');
+    }
+    await ensureAttested();
+    const sheetResponse = await FrameApplePay.presentApplePay({
+        amount: options.amount,
+        currency: options.currency ?? 'usd',
+        applePayMerchantId: merchantId,
+        supportedNetworks: DEFAULT_SUPPORTED_NETWORKS,
+    });
+    try {
+        const id = await createPaymentMethodAndCharge(options, sheetResponse);
+        // Settle through the safe wrapper too: if the native sheet already
+        // dismissed itself (background/foreground race), we still need to
+        // return the successful id — not blow up the payment that succeeded.
+        await safeFinishApplePay('success');
+        return id;
+    }
+    catch (err) {
+        await safeFinishApplePay('failure');
+        throw err;
+    }
+}
+/**
+ * Apple Pay "add to owner" flow. Presents the sheet, attests the device,
+ * creates a tokenized Apple Pay payment method via frame-node, then settles
+ * the sheet — but does NOT create a ChargeIntent or Transfer. Used by the
+ * onboarding AddPaymentMethod screen so the host app can collect a saved
+ * Apple Pay token for the account / customer.
+ *
+ * The presented sheet renders a $1.00 placeholder line item because Apple
+ * Pay requires a non-zero amount to draw the authorization UI. The amount
+ * is never charged.
+ */
+export async function addApplePayToOwnerFlow(options) {
+    if (Platform.OS !== 'ios') {
+        throw frameError(ErrorCodes.PLATFORM_UNSUPPORTED, 'Frame Apple Pay add-to-owner is iOS-only.');
+    }
+    validateOwner(options.owner);
+    const merchantId = getApplePayMerchantId();
+    if (!merchantId) {
+        throw frameError(ErrorCodes.INVALID_MERCHANT_ID, 'No Apple Pay merchant ID configured. Pass `applePayMerchantId` to Frame.initialize(...).');
+    }
+    await ensureAttested();
+    const currency = options.currency ?? 'usd';
+    // Apple Pay needs a non-zero amount on the request to draw the sheet. We
+    // use $1.00 (100 cents) — it's a label only, no charge is created.
+    const sheetResponse = await FrameApplePay.presentApplePay({
+        amount: 100,
+        currency,
+        applePayMerchantId: merchantId,
+        supportedNetworks: DEFAULT_SUPPORTED_NETWORKS,
+    });
+    try {
+        const wallet = await buildAppleWalletEnvelope(sheetResponse);
+        const params = options.owner.type === 'customer'
+            ? { type: 'card', customer: options.owner.id, _wallet: wallet }
+            : { type: 'card', account: options.owner.id, _wallet: wallet };
+        const pm = await client.sdk.paymentMethods.createApplePayPaymentMethod(params, {
+            usePublishableKey: true,
+        });
+        if (!pm || typeof pm.id !== 'string') {
+            throw frameError(ErrorCodes.PAYMENT_METHOD_FAILED, 'Frame returned no payment method id.');
+        }
+        await safeFinishApplePay('success');
+        return pm.id;
+    }
+    catch (err) {
+        await safeFinishApplePay('failure');
+        throw err;
+    }
+}
+async function buildAppleWalletEnvelope(sheetResponse) {
+    const paymentDataBytes = base64ToBytes(sheetResponse.token.paymentData);
+    const assertion = await generateAssertionForPayment(paymentDataBytes);
+    const paymentData = parsePaymentDataJson(sheetResponse.token.paymentData);
+    return {
+        type: 'apple_pay',
+        apple_pay: {
+            requestId: cryptoRandomUUID(),
+            methodName: 'https://apple.com/apple-pay',
+            payerName: sheetResponse.payerName,
+            payerEmail: sheetResponse.payerEmail,
+            details: {
+                token: {
+                    paymentData,
+                    paymentMethod: sheetResponse.token.paymentMethod,
+                    transactionIdentifier: sheetResponse.token.transactionIdentifier,
+                },
+                billingContact: sheetResponse.billingContact,
+            },
+            device_key_id: assertion.keyId,
+            device_assertion: assertion.assertion,
+            device_client_data: assertion.clientData,
+        },
+    };
+}
+async function createPaymentMethodAndCharge(options, sheetResponse) {
+    const paymentDataBytes = base64ToBytes(sheetResponse.token.paymentData);
+    const assertion = await generateAssertionForPayment(paymentDataBytes);
+    const paymentData = parsePaymentDataJson(sheetResponse.token.paymentData);
+    const currency = options.currency ?? 'usd';
+    const owner = options.owner;
+    const wallet = {
+        type: 'apple_pay',
+        apple_pay: {
+            requestId: cryptoRandomUUID(),
+            methodName: 'https://apple.com/apple-pay',
+            payerName: sheetResponse.payerName,
+            payerEmail: sheetResponse.payerEmail,
+            details: {
+                token: {
+                    paymentData,
+                    paymentMethod: sheetResponse.token.paymentMethod,
+                    transactionIdentifier: sheetResponse.token.transactionIdentifier,
+                },
+                billingContact: sheetResponse.billingContact,
+            },
+            device_key_id: assertion.keyId,
+            device_assertion: assertion.assertion,
+            device_client_data: assertion.clientData,
+        },
+    };
+    if (owner.type === 'customer') {
+        const pm = await client.sdk.paymentMethods.createApplePayPaymentMethod({ type: 'card', customer: owner.id, _wallet: wallet }, { usePublishableKey: true });
+        const intent = await client.sdk.chargeIntents.create({
+            amount: options.amount,
+            currency,
+            customer: owner.id,
+            payment_method: pm.id,
+            confirm: true,
+        });
+        if (!intent || typeof intent.id !== 'string') {
+            throw frameError(ErrorCodes.PAYMENT_FAILED, 'Frame returned no ChargeIntent id.');
+        }
+        return intent.id;
+    }
+    const pm = await client.sdk.paymentMethods.createApplePayPaymentMethod({ type: 'card', account: owner.id, _wallet: wallet }, { usePublishableKey: true });
+    const transfer = await client.sdk.transfers.create({
+        amount: options.amount,
+        account_id: owner.id,
+        currency,
+        source_payment_method_id: pm.id,
+    });
+    if (!transfer || typeof transfer.id !== 'string') {
+        throw frameError(ErrorCodes.PAYMENT_FAILED, 'Frame returned no Transfer id.');
+    }
+    return transfer.id;
+}
+async function safeFinishApplePay(status) {
+    try {
+        await FrameApplePay.finishApplePay(status);
+    }
+    catch {
+        // The sheet may have closed already on the native side (e.g. user
+        // backgrounded the app). Best-effort cleanup.
+    }
+}
+function validateOwner(owner) {
+    if (!owner || (owner.type !== 'customer' && owner.type !== 'account')) {
+        throw frameError(ErrorCodes.INVALID_OWNER, 'presentApplePay requires owner: { type: "customer" | "account", id: string }');
+    }
+    if (!owner.id) {
+        throw frameError(ErrorCodes.INVALID_OWNER, 'presentApplePay requires owner.id');
+    }
+}
+// PKPaymentToken.paymentData is a JSON dict that PassKit produces. We parse it
+// here so frame-node receives the wallet envelope's nested shape exactly the
+// way Frame's backend expects (per ApplePayRequests.swift).
+function parsePaymentDataJson(base64) {
+    const json = atobUtf8(base64);
+    return JSON.parse(json);
+}
+function atobUtf8(b64) {
+    return globalThis.atob ? globalThis.atob(b64) : Buffer.from(b64, 'base64').toString('utf-8');
+}
+function base64ToBytes(b64) {
+    const binary = globalThis.atob ? globalThis.atob(b64) : Buffer.from(b64, 'base64').toString('binary');
+    const out = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++)
+        out[i] = binary.charCodeAt(i);
+    return out;
+}
+function cryptoRandomUUID() {
+    const g = globalThis;
+    if (typeof g === 'object' &&
+        g !== null &&
+        'crypto' in g &&
+        typeof g.crypto?.randomUUID === 'function') {
+        return g.crypto.randomUUID();
+    }
+    // RFC4122 v4 fallback.
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}

package/lib/attestation.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Returns the attested key id stored in the Keychain, or null if the device
+ * hasn't been attested. Returns null on Android — parity with
+ * `isAttestationSupported()` which also degrades silently.
+ */
+export declare function getAttestedKeyId(): Promise<string | null>;
+/**
+ * Returns true if the device supports App Attest. False on simulator, on iOS
+ * < 14, and always on Android.
+ */
+export declare function isAttestationSupported(): Promise<boolean>;
+/**
+ * Full device attestation flow — mirrors `DeviceAttestationManager.attestDevice()`:
+ *   1. Reuse existing attested key if present.
+ *   2. Generate a key in the Secure Enclave (persisted as "pending").
+ *   3. Fetch a challenge from Frame.
+ *   4. SHA-256 the challenge as clientDataHash; attest via App Attest.
+ *   5. Submit the attestation object to Frame.
+ *   6. Promote the pending key to attested.
+ *
+ * Concurrent callers share a single in-flight promise so two parallel call
+ * sites don't each burn a fresh Secure Enclave key.
+ */
+export declare function ensureAttested(): Promise<string>;
+/**
+ * Generates an assertion bound to `paymentData`. Mirrors iOS
+ * `generateAssertionForPayment` — wraps the payment payload into a clientData
+ * JSON, SHA-256 hashes it, calls App Attest, and returns all three fields
+ * base64-encoded so the caller can embed them in the Apple Pay payment-method
+ * request.
+ *
+ * The returned `clientData` is the exact bytes the SHA-256 was computed over.
+ * Frame's backend must re-hash the submitted `clientData` (rather than parse +
+ * re-serialize as JSON) to verify the assertion — that's how Apple specifies
+ * App Attest assertions work. Each platform is self-consistent; the byte
+ * sequence across iOS and RN is not guaranteed to match (iOS uses
+ * `JSONSerialization`, RN uses `JSON.stringify`) and does not need to.
+ */
+export declare function generateAssertionForPayment(paymentData: Uint8Array): Promise<{
+    keyId: string;
+    assertion: string;
+    clientData: string;
+}>;
+/** Clears the attested key id so the next `ensureAttested()` runs a fresh flow. */
+export declare function resetAttestation(): Promise<void>;
+/** @internal Resets the in-flight ensureAttested promise. Used by tests. */
+export declare function __resetEnsureAttestedInflight(): void;
+//# sourceMappingURL=attestation.d.ts.map

package/lib/attestation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attestation.d.ts","sourceRoot":"","sources":["../src/attestation.ts"],"names":[],"mappings":"AAwCA;;;;GAIG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAG/D;AAED;;;GAGG;AACH,wBAAsB,sBAAsB,IAAI,OAAO,CAAC,OAAO,CAAC,CAG/D;AAID;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC,CAMhD;AA4ED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,2BAA2B,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC;IAClF,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC,CA8BD;AAED,mFAAmF;AACnF,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAGtD;AAwDD,4EAA4E;AAC5E,wBAAgB,6BAA6B,IAAI,IAAI,CAEpD"}

package/lib/attestation.js

@@ -0,0 +1,207 @@
+import { NativeModules, Platform } from 'react-native';
+import { sha256 } from 'js-sha256';
+import { client } from './client';
+import { ErrorCodes, frameError } from './errors';
+const LINKING_ERROR = "The native module 'FrameAttestation' isn't linked. " +
+    'Make sure you have run `pod install` and rebuilt the app.';
+const FrameAttestation = NativeModules.FrameAttestation
+    ? NativeModules.FrameAttestation
+    : new Proxy({}, {
+        get() {
+            throw new Error(LINKING_ERROR);
+        },
+    });
+function guardIos() {
+    if (Platform.OS !== 'ios') {
+        throw frameError('PLATFORM_UNSUPPORTED', 'Device attestation is iOS-only (Apple App Attest). Android has no equivalent in this SDK.');
+    }
+}
+/**
+ * Returns the attested key id stored in the Keychain, or null if the device
+ * hasn't been attested. Returns null on Android — parity with
+ * `isAttestationSupported()` which also degrades silently.
+ */
+export async function getAttestedKeyId() {
+    if (Platform.OS !== 'ios')
+        return null;
+    return FrameAttestation.attestedKeyId();
+}
+/**
+ * Returns true if the device supports App Attest. False on simulator, on iOS
+ * < 14, and always on Android.
+ */
+export async function isAttestationSupported() {
+    if (Platform.OS !== 'ios')
+        return false;
+    return FrameAttestation.isSupported();
+}
+let inflightEnsureAttested = null;
+/**
+ * Full device attestation flow — mirrors `DeviceAttestationManager.attestDevice()`:
+ *   1. Reuse existing attested key if present.
+ *   2. Generate a key in the Secure Enclave (persisted as "pending").
+ *   3. Fetch a challenge from Frame.
+ *   4. SHA-256 the challenge as clientDataHash; attest via App Attest.
+ *   5. Submit the attestation object to Frame.
+ *   6. Promote the pending key to attested.
+ *
+ * Concurrent callers share a single in-flight promise so two parallel call
+ * sites don't each burn a fresh Secure Enclave key.
+ */
+export function ensureAttested() {
+    if (inflightEnsureAttested)
+        return inflightEnsureAttested;
+    inflightEnsureAttested = runEnsureAttested().finally(() => {
+        inflightEnsureAttested = null;
+    });
+    return inflightEnsureAttested;
+}
+async function runEnsureAttested() {
+    guardIos();
+    const existing = await FrameAttestation.attestedKeyId();
+    if (existing)
+        return existing;
+    if (!(await FrameAttestation.isSupported())) {
+        throw frameError(ErrorCodes.NOT_ATTESTED, 'App Attest is not supported on this device (iOS 14+ on a real device required).');
+    }
+    const keyId = await wrapped('generateKey', () => FrameAttestation.generateKey());
+    let challenge;
+    try {
+        const challengeResponse = await client.sdk.deviceAttestation.getChallenge({ usePublishableKey: true });
+        challenge = challengeResponse.challenge ?? '';
+        if (!challenge) {
+            throw frameError(ErrorCodes.ATTESTATION_FAILED, 'Frame backend returned no attestation challenge.');
+        }
+    }
+    catch (err) {
+        await safeClearPending();
+        if (err.code === ErrorCodes.ATTESTATION_FAILED)
+            throw err;
+        throw frameError(ErrorCodes.ATTESTATION_FAILED, `Device attestation challenge failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const clientDataHash = sha256Base64(base64ToBytes(challenge));
+    let attestationObject;
+    try {
+        attestationObject = await FrameAttestation.attestKey(keyId, clientDataHash);
+    }
+    catch (err) {
+        // attestKey is single-use per key; the Swift bridge already cleans up
+        // the pending entry on failure.
+        throw frameError(ErrorCodes.ATTESTATION_FAILED, `App Attest attestKey failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (!attestationObject) {
+        await safeClearPending();
+        throw frameError(ErrorCodes.ATTESTATION_FAILED, 'App Attest returned an empty attestation object.');
+    }
+    let attestResponse;
+    try {
+        attestResponse = await client.sdk.deviceAttestation.attest({ key_id: keyId, attestation_object: attestationObject, challenge }, { usePublishableKey: true });
+    }
+    catch (err) {
+        await safeClearPending();
+        throw frameError(ErrorCodes.ATTESTATION_FAILED, `Frame backend attest failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (attestResponse.status !== 'verified') {
+        await safeClearPending();
+        throw frameError(ErrorCodes.ATTESTATION_FAILED, `Frame backend rejected attestation (status: ${attestResponse.status}).`);
+    }
+    await FrameAttestation.promoteKey(keyId);
+    return keyId;
+}
+/**
+ * Generates an assertion bound to `paymentData`. Mirrors iOS
+ * `generateAssertionForPayment` — wraps the payment payload into a clientData
+ * JSON, SHA-256 hashes it, calls App Attest, and returns all three fields
+ * base64-encoded so the caller can embed them in the Apple Pay payment-method
+ * request.
+ *
+ * The returned `clientData` is the exact bytes the SHA-256 was computed over.
+ * Frame's backend must re-hash the submitted `clientData` (rather than parse +
+ * re-serialize as JSON) to verify the assertion — that's how Apple specifies
+ * App Attest assertions work. Each platform is self-consistent; the byte
+ * sequence across iOS and RN is not guaranteed to match (iOS uses
+ * `JSONSerialization`, RN uses `JSON.stringify`) and does not need to.
+ */
+export async function generateAssertionForPayment(paymentData) {
+    guardIos();
+    const keyId = await FrameAttestation.attestedKeyId();
+    if (!keyId) {
+        throw frameError(ErrorCodes.NOT_ATTESTED, 'No attested key on this device. Call ensureAttested() first.');
+    }
+    const clientDataJson = JSON.stringify({
+        challenge: bytesToBase64(paymentData),
+        origin: 'ios-sdk',
+    });
+    const clientDataBytes = textEncoderEncode(clientDataJson);
+    const clientDataHash = sha256Base64(clientDataBytes);
+    let assertion;
+    try {
+        assertion = await FrameAttestation.generateAssertion(keyId, clientDataHash);
+    }
+    catch (err) {
+        throw frameError(ErrorCodes.ATTESTATION_FAILED, `App Attest generateAssertion failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return {
+        keyId,
+        assertion,
+        clientData: bytesToBase64(clientDataBytes),
+    };
+}
+/** Clears the attested key id so the next `ensureAttested()` runs a fresh flow. */
+export async function resetAttestation() {
+    guardIos();
+    await FrameAttestation.resetAttestation();
+}
+// ----- helpers -----
+async function wrapped(stage, fn) {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        throw frameError(ErrorCodes.ATTESTATION_FAILED, `Device attestation ${stage} failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+async function safeClearPending() {
+    try {
+        await FrameAttestation.clearPendingKey();
+    }
+    catch {
+        // Best-effort cleanup; the next ensureAttested will overwrite the entry.
+    }
+}
+function sha256Base64(bytes) {
+    // js-sha256 emits a hex digest by default; convert to bytes then base64.
+    const hex = sha256(bytes);
+    const out = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < out.length; i++) {
+        out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytesToBase64(out);
+}
+function base64ToBytes(b64) {
+    // Hermes ships atob/btoa from RN 0.74+. The Buffer fallback is only hit
+    // under Node (jest tests).
+    const binary = globalThis.atob ? globalThis.atob(b64) : Buffer.from(b64, 'base64').toString('binary');
+    const out = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++)
+        out[i] = binary.charCodeAt(i);
+    return out;
+}
+function bytesToBase64(bytes) {
+    if (globalThis.btoa) {
+        let binary = '';
+        for (let i = 0; i < bytes.length; i++)
+            binary += String.fromCharCode(bytes[i]);
+        return globalThis.btoa(binary);
+    }
+    return Buffer.from(bytes).toString('base64');
+}
+function textEncoderEncode(text) {
+    if (typeof TextEncoder !== 'undefined')
+        return new TextEncoder().encode(text);
+    return new Uint8Array(Buffer.from(text, 'utf-8'));
+}
+/** @internal Resets the in-flight ensureAttested promise. Used by tests. */
+export function __resetEnsureAttestedInflight() {
+    inflightEnsureAttested = null;
+}

package/lib/camera.d.ts

@@ -0,0 +1,29 @@
+export interface CapturedPhoto {
+    /** Local file URI for the captured image. Pass to FormData as-is. */
+    uri: string;
+    /** MIME type, e.g. 'image/jpeg'. */
+    type: string;
+    /** Suggested file name for multipart upload. */
+    name: string;
+}
+interface VisionCameraModule {
+    Camera: unknown;
+    useCameraDevice?: unknown;
+    __version?: string;
+}
+export declare function loadCameraSdk(): VisionCameraModule | null;
+export declare function isCameraAvailable(): boolean;
+export interface CameraPermissionStatus {
+    granted: boolean;
+    requestable: boolean;
+}
+/**
+ * Request camera permission. The wrapper hides the SDK-version-specific
+ * permission-request API behind a single function so the screens can stay
+ * agnostic. Returns granted=true when the user authorizes, granted=false
+ * with requestable=false when the user has permanently denied.
+ */
+export declare function requestCameraPermission(): Promise<CameraPermissionStatus>;
+export declare function __resetCameraSdkCache(): void;
+export {};
+//# sourceMappingURL=camera.d.ts.map

package/lib/camera.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera.d.ts","sourceRoot":"","sources":["../src/camera.ts"],"names":[],"mappings":"AAaA,MAAM,WAAW,aAAa;IAC5B,qEAAqE;IACrE,GAAG,EAAE,MAAM,CAAC;IACZ,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,kBAAkB;IAE1B,MAAM,EAAE,OAAO,CAAC;IAChB,eAAe,CAAC,EAAE,OAAO,CAAC;IAG1B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAID,wBAAgB,aAAa,IAAI,kBAAkB,GAAG,IAAI,CAUzD;AAED,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,OAAO,CAAC;CACtB;AAED;;;;;GAKG;AACH,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,sBAAsB,CAAC,CAiC/E;AAGD,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C"}

package/lib/camera.js

@@ -0,0 +1,61 @@
+import { Platform } from 'react-native';
+import { frameError, ErrorCodes } from './errors';
+let cachedSdk;
+export function loadCameraSdk() {
+    if (cachedSdk !== undefined)
+        return cachedSdk;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const mod = require('react-native-vision-camera');
+        cachedSdk = mod;
+    }
+    catch {
+        cachedSdk = null;
+    }
+    return cachedSdk;
+}
+export function isCameraAvailable() {
+    return loadCameraSdk() !== null;
+}
+/**
+ * Request camera permission. The wrapper hides the SDK-version-specific
+ * permission-request API behind a single function so the screens can stay
+ * agnostic. Returns granted=true when the user authorizes, granted=false
+ * with requestable=false when the user has permanently denied.
+ */
+export async function requestCameraPermission() {
+    const sdk = loadCameraSdk();
+    if (!sdk) {
+        throw frameError(ErrorCodes.CAMERA_UNAVAILABLE, 'react-native-vision-camera is not installed. Add it to your peer deps and rebuild.');
+    }
+    // v4: Camera.requestCameraPermission() → 'authorized' | 'denied' | 'restricted'
+    // v5: Camera.requestCameraPermission() → 'granted' | 'denied' | 'restricted'
+    // Both ship a static method on the Camera class with the same name; the
+    // result string varies. Normalize.
+    const CameraClass = sdk.Camera;
+    if (!CameraClass?.requestCameraPermission) {
+        // Older SDK didn't expose static permission; fall back to deny.
+        return { granted: false, requestable: false };
+    }
+    try {
+        const result = await CameraClass.requestCameraPermission();
+        const norm = result?.toLowerCase() ?? '';
+        if (norm === 'granted' || norm === 'authorized') {
+            return { granted: true, requestable: false };
+        }
+        // iOS prompts the user exactly once. After 'denied' the OS returns the
+        // cached value forever — only the Settings app can change it. Android
+        // re-prompts on subsequent requests UNLESS the user enabled "Don't ask
+        // again," but RN doesn't expose that distinction, so conservatively
+        // mark Android-denied as requestable. 'restricted' (parental controls)
+        // is irrecoverable on both platforms.
+        return { granted: false, requestable: Platform.OS === 'android' && norm === 'denied' };
+    }
+    catch {
+        return { granted: false, requestable: Platform.OS === 'android' };
+    }
+}
+// Test-only — flushes the cache so tests can swap implementations.
+export function __resetCameraSdkCache() {
+    cachedSdk = undefined;
+}

package/lib/client.d.ts

@@ -0,0 +1,7 @@
+import { FrameSDK } from 'framepayments';
+export declare function resetClients(): void;
+export declare function warmClients(): boolean;
+export declare const client: {
+    readonly sdk: FrameSDK;
+};
+//# sourceMappingURL=client.d.ts.map

package/lib/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AA4BzC,wBAAgB,YAAY,IAAI,IAAI,CAGnC;AAED,wBAAgB,WAAW,IAAI,OAAO,CAIrC;AAED,eAAO,MAAM,MAAM;kBACN,QAAQ;CAGpB,CAAC"}

package/lib/client.js

@@ -0,0 +1,38 @@
+import { FrameSDK } from 'framepayments';
+import { getIpAddress, getPublishableKey, getSecretKey } from './config';
+import { frameError, ErrorCodes } from './errors';
+import { attachNetworkLogger, resetNetworkLogger } from './debug/networkLogger';
+let sdk;
+function getClient() {
+    if (sdk)
+        return sdk;
+    const apiKey = getSecretKey();
+    const publishableKey = getPublishableKey();
+    if (!apiKey && !publishableKey) {
+        throw frameError(ErrorCodes.NOT_INITIALIZED, 'Frame SDK is not configured. Call Frame.initialize({ secretKey, publishableKey }) first.');
+    }
+    // Forward the device IP via the `ip_address` header on every request,
+    // matching the native Frame iOS / Frame Android SDKs. Omitted when the
+    // lookup hasn't completed yet — the next client construction (after
+    // resetClients() in the IP-fetch resolver) will pick it up.
+    const ip = getIpAddress();
+    const defaultHeaders = ip ? { ip_address: ip } : undefined;
+    sdk = new FrameSDK({ apiKey, publishableKey, defaultHeaders });
+    attachNetworkLogger(sdk);
+    return sdk;
+}
+export function resetClients() {
+    sdk = undefined;
+    resetNetworkLogger();
+}
+export function warmClients() {
+    if (!getSecretKey() && !getPublishableKey())
+        return false;
+    getClient();
+    return true;
+}
+export const client = {
+    get sdk() {
+        return getClient();
+    },
+};

package/lib/config.d.ts

@@ -0,0 +1,40 @@
+import type { FrameTheme } from './types';
+export interface FrameConfig {
+    secretKey?: string;
+    publishableKey?: string;
+    debugMode: boolean;
+    applePayMerchantId?: string;
+    googlePayMerchantId?: string;
+    theme?: FrameTheme;
+}
+export interface EvervaultConfiguration {
+    teamId: string;
+    appId: string;
+}
+export interface SiftConfiguration {
+    accountId: string;
+    beaconKey: string;
+    sessionId?: string;
+}
+export declare function setConfig(config: FrameConfig): void;
+export declare function getConfig(): Readonly<FrameConfig>;
+export declare function isInitialized(): boolean;
+export declare function getPublishableKey(): string | undefined;
+export declare function getSecretKey(): string | undefined;
+export declare function getDebugMode(): boolean;
+export declare function getTheme(): FrameTheme | undefined;
+export declare function getApplePayMerchantId(): string | undefined;
+export declare function getGooglePayMerchantId(): string | undefined;
+export declare function getEvervaultConfiguration(): EvervaultConfiguration | undefined;
+export declare function getSiftConfiguration(): SiftConfiguration | undefined;
+export declare function getIpAddress(): string | undefined;
+export declare function resetConfig(): void;
+export declare const __internal: {
+    setEvervaultConfiguration(config: EvervaultConfiguration): void;
+    getEvervaultConfiguration(): EvervaultConfiguration | undefined;
+    setSiftConfiguration(config: SiftConfiguration): void;
+    getSiftConfiguration(): SiftConfiguration | undefined;
+    setIpAddress(ip: string | undefined): void;
+    getIpAddress(): string | undefined;
+};
+//# sourceMappingURL=config.d.ts.map