@tapayadot/accept-react-native 1.3.2 → 1.14.1

package/README.md

@@ -1,462 +1,295 @@
-![AcceptSDK](banner-github.png)
+![Tapaya Accept](banner-github.png)
 
-![Platform](https://img.shields.io/badge/platform-React%20Native-blue) ![iOS](https://img.shields.io/badge/iOS-26%2B-blue) ![Android](https://img.shields.io/badge/Android-11%2B-green) [![Docs](https://img.shields.io/badge/docs-tapaya.com-blue)](https://docs.tapaya.com) [![License](https://img.shields.io/badge/license-Apache%202.0-blue)](LICENSE) [![npm](https://img.shields.io/badge/npm-accept--sdk--react--native-red)](https://www.npmjs.com/package/@tapayadot/accept-react-native)
+# Tapaya Accept SDK for React Native
 
-React Native / Expo SDK for integrating Tapaya Accept payment processing into your app.
+Accept card payments on Android terminals from a React Native or Expo app.
 
-## Installation
-
-```sh
-npm install @tapayadot/accept-react-native
-```
+This package is a thin wrapper over the [Accept SDK for Android](https://docs.tapaya.com)
+(`com.tapaya:accept`), which in turn drives the **Accept plugin app** — the companion
+installed on the terminal that owns the card reader and the payment UI. Every surface here
+mirrors the Android SDK 1:1, so its reference documentation applies unchanged.
 
-### Expo plugin
+Full documentation: [docs.tapaya.com](https://docs.tapaya.com)
 
-Add the plugin to your `app.json`. The plugin automatically configures the native Android Maven repository and iOS Swift Package Manager dependency:
+## Requirements
 
-```json
-{
-  "expo": {
-    "plugins": ["@tapayadot/accept-react-native"]
-  }
-}
-```
+- **Android only.** There is no iOS implementation. The package is safe to import on
+  iOS, but every call throws, so guard them with `Platform.OS === 'android'`.
+- **`minSdkVersion` 30** (Android 11). The config plugin raises the host app to match.
+- **Expo SDK 54+**, or a bare React Native app using `expo-modules-core`. Verified against
+  SDK 57 / React Native 0.86 on an Android 16 terminal.
+- A **custom development build** — this package contains native code and does not run in
+  Expo Go.
 
-Then run:
+## Installation
 
 ```sh
-npx expo prebuild
+npx expo install @tapayadot/accept-react-native
 ```
 
-#### Plugin options
-
-The plugin accepts options to toggle optional native features. Pass them as the second element of the plugin entry in `app.json`:
-
-| Option | Type | Default | Description |
-|---|---|---|---|
-| `enableStripe` | `boolean` | `false` | Android only. Bundle the optional `com.tapaya:accept-stripe` dependency. Enable this only if your merchant account uses Stripe-backed payment processing. |
+Add the config plugin to `app.json`:
 
 ```json
 {
   "expo": {
-    "plugins": [
-      [
-        "@tapayadot/accept-react-native",
-        { "enableStripe": true }
-      ]
-    ]
+    "plugins": ["@tapayadot/accept-react-native"]
   }
 }
 ```
 
-When `enableStripe` is `true`, the plugin writes `com.tapaya.accept.enableStripe=true` into your app's `android/gradle.properties` during prebuild, which adds `com.tapaya:accept-stripe` to the Android build. iOS payment processing is bundled in the Swift Package and requires no flag.
-
-Re-run prebuild after changing plugin options so the native projects pick up the change:
+Then rebuild the native project:
 
 ```sh
 npx expo prebuild --clean
+npx expo run:android
 ```
 
-### Android
-
-The Android SDK is distributed via Maven Central, which is a default repository in every Android project — no additional repository configuration is required.
-
-### iOS
-
-The iOS SDK is resolved via Swift Package Manager during `prebuild` / `pod install`. No additional configuration is required.
-
-## Requirements
-
-- React Native 0.74+ / Expo SDK 51+
-- iOS 26+
-- Android API 30+
-
-## Usage
+The plugin only raises `minSdkVersion` to 30. Everything else the SDK needs — the
+`INTERNET`, `ACCESS_NETWORK_STATE`, and location permissions, the `<queries>` entries that
+make the plugin app visible on API 30+, and the activities that run a payment on a
+customer-facing display — ships in the Android SDK's own manifest and merges in
+automatically.
 
-### Setup
+## Quick start
 
 ```ts
 import Accept from '@tapayadot/accept-react-native';
 
-// Initialize once at app launch
-await Accept.initialize(/* demo: */ false);
+// 1. Initialize once, at app startup.
+Accept.initialize({ isProduction: false }); // false = sandbox
 
-// Authenticate with your merchant token
-await Accept.authenticate('your-merchant-token');
-```
+// 2. Authenticate the merchant.
+await Accept.auth.authenticate(merchantToken);
 
-### UI Theming
+// 3. Make sure the plugin app is installed and its terminal is activated.
+if (!Accept.plugin.isInstalled()) {
+  await Accept.plugin.install(); // opens the store listing
+}
+if ((await Accept.plugin.status()) !== 'readyForPayments') {
+  await Accept.plugin.activateTerminal();
+}
 
-Customize colors and logos at initialization or any time after:
+// 4. Take a payment. Amounts are in the currency's minor unit.
+const result = await Accept.payments.payAsync({ amount: 1000, currency: 'USD' });
+if (result.type === 'success') {
+  console.log(result.paymentToken, result.receiptUrl);
+}
+```
 
-```ts
-import Accept, { type AcceptThemeConfiguration } from '@tapayadot/accept-react-native';
-import { assetToBase64 } from '@tapayadot/accept-react-native/utils';
+### Location permission
 
-const theme: AcceptThemeConfiguration = {
-  colors: {
-    accent: '#FF8400',
-    error: '#E6282B',
-    warning: '#FF8000',
-    success: '#228800',
-    brandGradientColors: { start: '#FF8400', end: '#9A94E9' },
-  },
-  images: {
-    brandLogo:   await assetToBase64(require('./assets/brand-logo.png')),
-    toolbarLogo: await assetToBase64(require('./assets/toolbar-logo.png')),
-    solidLogo:   await assetToBase64(require('./assets/solid-logo.png')),
-  },
-};
+A payment requires a device location fix, and the **host app** must request the permission —
+the SDK does not. Request it before the first payment, or it fails with
+`LocationPermissionRequired`:
 
-// Pass at initialization
-await Accept.initialize(false, theme);
+```ts
+import { PermissionsAndroid } from 'react-native';
 
-// Or apply after initialization
-await Accept.setTheme(theme);
+await PermissionsAndroid.request(PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION);
 ```
 
-Omit `colors` or `images` to keep SDK defaults for that slot. Images must be PNG or JPEG — SVG is not supported.
+## API
 
-> `assetToBase64` requires `expo-asset` and `expo-file-system`. Both are included in managed Expo projects. Bare React Native users must install them manually.
+Everything hangs off the default export.
 
-### Request Location Permission
+| Surface  | Access             | Purpose                                                                        |
+| -------- | ------------------ | ------------------------------------------------------------------------------ |
+| State    | `Accept.state`     | `'idle' \| 'initialized' \| 'authenticated'`, plus `addStateListener()`         |
+| Auth     | `Accept.auth`      | `authenticate(merchantToken)`                                                   |
+| SDK      | `Accept.sdk`       | `version`, `isProduction`, `deviceId()`, `minimumAmounts()`                     |
+| Merchant | `Accept.merchant`  | `info()`, `config()`, `onboardingStatus()`, `availableCurrencies()`             |
+| Payments | `Accept.payments`  | `pay()`, `payAsync()`, `status()`, `cancel()`, `refund()`, `setOptions()`       |
+| Plugin   | `Accept.plugin`    | `isInstalled()`, `install()`, `activateTerminal()`, `status()`, `updateInfo()`, `logout()` |
+| Displays | `Accept.displays`  | `all()`, `customerFacing()`, `isDualScreen`                                     |
 
-Required before processing card payments (Tap-to-Pay):
+Top-level: `initialize()`, `clear()`, `setTheme()`, `getTheme()`,
+`createLocalThemeImageUri()`, `setLogLevel()`, `setDebugLoggingEnabled()`, `setLogger()`.
 
-```ts
-await Accept.requestLocationPermission();
-```
+### Lifecycle
 
-### Card Payment (Tap-to-Pay)
+`Accept.state` moves `idle → initialized → authenticated`:
 
 ```ts
-import Accept, { CardPaymentIntent } from '@tapayadot/accept-react-native';
-
-const intent: CardPaymentIntent = {
-  paymentIntentId: 'pi_xxx',
-  amount: 1500,
-  requestedCurrency: 'CZK',        // ISO 4217 alpha-3
-  settlementCurrency: 'EUR',
-};
-
-const result = await Accept.payments.startCardPayment(
-  intent,
-  (status) => console.log('Status update:', status),
-  (message, exception) => console.error('Error:', message, exception),
-);
-
-switch (result.status) {
-  case 'approved':
-    console.log('Approved:', result.authorizationCode);
-    break;
-  case 'declined':
-    console.log('Declined:', result.reason);
-    break;
-}
+const subscription = Accept.addStateListener((state) => {
+  if (state === 'authenticated') loadMerchant();
+});
+
+// later
+subscription.remove();
 ```
 
-### Refund a Card Payment
+### Payments as a stream
+
+`payAsync()` is a convenience over `pay()`, which reports the whole lifecycle. Use it when
+the UI reflects the intermediate states:
 
 ```ts
-const refund = await Accept.payments.refund({
-  paymentToken: 'pi_xxx',          // source payment intent id (or server payment UUID)
-  reason: 'customerRequest',       // 'customerRequest' | 'duplicate' | 'fraudulent' | 'expiredCharge'
+const subscription = Accept.payments.pay({ amount: 1000, currency: 'USD' }, (event) => {
+  switch (event.type) {
+    case 'creating':
+      setStatus('Creating payment…');
+      break;
+    case 'created':
+      // The payment token and receipt URL exist before the plugin is launched.
+      setReceiptUrl(event.receiptUrl);
+      break;
+    case 'launched':
+      setStatus('Waiting for the card…');
+      break;
+    case 'result':
+      setResult(event.payResult); // success | declined | canceled | failed
+      break;
+    case 'creationFailed':
+      setError(event.error); // an AcceptError payload; the payment never started
+      break;
+  }
 });
-
-console.log(refund.status);        // 'success' | 'pending' | 'cancelled' | 'refunded' | 'failed' | 'actionNeeded'
 ```
 
-### Cancel an Active Payment
+`pay()` never throws — a failure to create the payment arrives as `creationFailed`. The
+stream ends after `result` or `creationFailed` and the subscription removes itself; call
+`subscription.remove()` to stop listening early (the plugin's UI stays on screen).
 
-```ts
-// Dismisses any payment UI and cancels the in-flight transaction.
-await Accept.payments.cancelActivePayment();
-```
+### Payment options
 
-### SEPA Instant Credit Transfer
+Per payment, or session-wide via `Accept.payments.setOptions()`:
 
 ```ts
-const result = await Accept.payments.startSepaPayment(
-  {
-    paymentIntentId: 'pi_xxx',
-    amount: 1000,
-    requestedCurrency: 'EUR',
-    settlementCurrency: 'EUR',
+Accept.payments.setOptions({
+  receiptConfig: {
+    type: 'show',
+    showQrCodeReceipt: true,
+    dismissBehavior: { type: 'delayed', delayMs: 5000 },
+    printBehavior: 'onDemand',
   },
-  (status) => console.log('Status update:', status),
-  (message, exception) => console.error('Error:', message, exception),
-);
+  nfcPosition: { type: 'onDevice', surface: 'back', xFraction: 0.5, yFraction: 0.25 },
+  transactionTimeoutMs: 60_000, // 0…120000
+});
 
-if (result.status === 'verified') {
-  console.log('Received from:', result.receivedFromIban);
-}
+await Accept.payments.payAsync({
+  amount: 2500,
+  currency: 'EUR',
+  tip: 250, // skips the plugin's own tip screen
+  metadata: { orderId: 'A-1024' }, // echoed back on the result
+});
 ```
 
-### Certis (Czech Instant Transfer)
+Only the keys you pass are changed, so one default can be set without disturbing the others.
 
-```ts
-const result = await Accept.payments.startCertisPayment(
-  {
-    paymentIntentId: 'pi_xxx',
-    amount: 10000,
-    requestedCurrency: 'CZK',
-    settlementCurrency: 'CZK',
-  },
-  (status) => console.log('Status update:', status),
-  (message, exception) => console.error('Error:', message, exception),
-);
-```
+### Dual-screen terminals
 
-### Onboarding Status
+On dual-sided hardware, run the payment UI on the customer-facing panel while your app keeps
+the merchant panel:
 
 ```ts
-// Aggregate status across all payment methods
-const onboarding = await Accept.identity.getOnboardingStatus();
-console.log(onboarding.isOnboarded);
-onboarding.paymentMethods.forEach((m) =>
-  console.log(m.method, m.status), // e.g. 'CARD', 'ACTIVE'
-);
-
-// Single-method status
-const cardStatus = await Accept.identity.getPaymentMethodStatus('CARD');
-// 'NOT_STARTED' | 'PENDING' | 'ACTIVE' | 'ATTENTION_NEEDED' | 'ACTION_REQUIRED' | 'BLOCKED'
+if (Accept.displays.isDualScreen) {
+  Accept.payments.setOptions({ display: { type: 'customerFacing' } });
+}
 ```
 
-### KYB Onboarding
+Set this **before** `authenticate()` — the terminal warm-up it fires follows the same target,
+and you don't want the warm-up flashing on the merchant's screen.
 
-```ts
-// Check if onboarding is needed before launching the KYB flow
-await Accept.identity.presentKyb({
-  businessType: 'company',
-  legalName: 'Acme s.r.o.',
-  businessEmail: 'billing@acme.com',
-  countryCode: 'CZ',
-  registrationNumber: '12345678',
-  vatNumber: 'CZ12345678',
-  addressLine1: 'Václavské náměstí 1',
-  city: 'Praha',
-  postalCode: '11000',
-  bankAccountIban: 'CZ...',
-  businessUrl: 'https://acme.com',
-  productDescription: 'SaaS platform',
-  supportPhone: '+420123456789',
-});
-```
+### Errors
 
-### Session Management
+Every rejection is an `AcceptError` whose `code` names the failure, carrying that case's
+fields:
 
 ```ts
-// Check current SDK status
-const status = await Accept.getStatus(); // 'IDLE' | 'INITIALIZED' | 'LOGGED_IN'
-
-// Query the result of a previous payment
-const result = await Accept.getPaymentStatus('pi_xxx');
-
-// Log out
-await Accept.logOut();
+import Accept, { AcceptError } from '@tapayadot/accept-react-native';
+
+try {
+  await Accept.payments.payAsync({ amount: 10, currency: 'USD' });
+} catch (error) {
+  if (!AcceptError.is(error)) throw error;
+
+  switch (error.code) {
+    case 'AmountBelowMinimum':
+      alert(`Minimum is ${error.minimum} ${error.currency}`);
+      break;
+    case 'PluginNotReadyForPayments':
+      await Accept.plugin.activateTerminal();
+      break;
+    case 'LocationPermissionRequired':
+      await requestLocationPermission();
+      break;
+    case 'NoInternetConnection':
+      alert('No connection.');
+      break;
+    default:
+      throw error;
+  }
+}
 ```
 
-### Demo Mode
-
-```ts
-await Accept.demo.enable();        // simulate payments without real terminals
-const isDemo = await Accept.demo.isEnabled();
-await Accept.demo.disable();
-```
+### Theming
 
-### UI Behavior (Android only)
+Branding for the plugin's activation, status, and payment screens. Session-wide, and pushed
+to the plugin the next time it is bound or launched:
 
 ```ts
-await Accept.setUiBehavior({
-  resultScreenDurationSeconds: 5,
-  showResultScreen: true,
-  nfcZone: {
-    indicator: 'BELOW',              // 'DEFAULT' | 'ABOVE' | 'BELOW' | 'FRONT' | 'BEHIND'
-    position: { xBias: 0.5, yBias: 0.7 }, // omit to use terminal default
+Accept.setTheme({
+  light: {
+    colors: { primary: '#0B5FFF', onPrimary: '#FFFFFF', surface: '#FFFFFF' },
+    images: { logoSymbol: 'https://example.com/logo.png' },
+  },
+  dark: {
+    colors: { primary: '#6E9BFF', onPrimary: '#001B3D', surface: '#101418' },
   },
 });
 ```
 
-### Companion App
-
-The Tapaya companion app is required for card payments. Supported on both iOS and Android:
+For a logo bundled with the app rather than hosted, convert it and hand the plugin a
+`content://` URL:
 
 ```ts
-const installed = await Accept.isCompanionAppInstalled();
-
-if (!installed) {
-  // Prompt user to install via the store product sheet (App Store on iOS, Play Store on Android)
-  await Accept.presentCompanionAppSheet();
-} else {
-  // Pair with the companion app (rejects if it is not installed or not ready)
-  await Accept.pairWithCompanionApp();
-}
-```
-
-## API Reference
-
-### Top-level
-
-| Method | Description |
-|---|---|
-| `initialize(demo?, theme?)` | Initialize the SDK. Pass `true` for sandbox mode. Optionally provide a UI theme. |
-| `setTheme(theme)` | Apply a UI theme after initialization. |
-| `setUiBehavior(behavior)` | Android only. Configure result screen + NFC zone. |
-| `authenticate(token)` | Authenticate with a merchant JWT token. |
-| `getStatus()` | Returns `'IDLE' \| 'INITIALIZED' \| 'LOGGED_IN'`. |
-| `getPaymentStatus(paymentIntentId)` | Retrieve the result of a previous payment. |
-| `logOut()` | End the current merchant session. |
-| `requestLocationPermission()` | Request location permission (required for card payments). |
-| `isCompanionAppInstalled()` | Check if the Tapaya companion app is installed. |
-| `presentCompanionAppSheet()` | Show the store product sheet for the companion app (App Store on iOS, Play Store on Android). |
-| `pairWithCompanionApp()` | Pair with the installed companion app. |
-
-### `Accept.payments`
-
-| Method | Description |
-|---|---|
-| `startCardPayment(intent, onStatus, onError)` | Start a card/Tap-to-Pay payment. |
-| `startSepaPayment(intent, onStatus, onError)` | Start a SEPA Instant payment. |
-| `startCertisPayment(intent, onStatus, onError)` | Start a Certis Instant payment. |
-| `refund(intent)` | Refund a previously completed card payment (headless, no UI). |
-| `cancelActivePayment()` | Dismiss in-flight payment UI and cancel the transaction. |
-
-### `Accept.identity`
-
-| Method | Description |
-|---|---|
-| `presentKyb(prefilling?)` | Launch the KYB onboarding UI with optional prefill data. |
-| `getOnboardingStatus()` | Returns aggregate merchant onboarding status across payment methods. |
-| `getPaymentMethodStatus(method)` | Returns onboarding status for a single payment method. |
+import { assetToBase64 } from '@tapayadot/accept-react-native/utils';
 
-### `Accept.demo`
+const base64 = await assetToBase64(require('./assets/logo.png'));
+const uri = Accept.createLocalThemeImageUri(base64, 'png');
 
-| Method | Description |
-|---|---|
-| `enable()` | Enable demo mode — payments are simulated, no real terminal required. |
-| `disable()` | Return to real terminal flows. |
-| `isEnabled()` | Whether demo mode is currently enabled. |
+Accept.setTheme({ light: { images: { logoSymbol: uri } } });
+```
 
-## Types
+`assetToBase64` needs `expo-asset` and `expo-file-system`, both present in managed Expo
+projects. Bare React Native consumers must install them.
 
-Currency and country fields are plain ISO strings:
-- Currency — ISO 4217 alpha-3 (`'CZK'`, `'EUR'`, `'GBP'`, …)
-- Country — ISO 3166-1 alpha-2 (`'CZ'`, `'GB'`, …)
+### Logging
 
 ```ts
-type CardPaymentIntent = {
-  paymentIntentId: string
-  amount: number                   // smallest currency unit (e.g. hellers)
-  requestedCurrency: string        // ISO 4217 alpha-3
-  settlementCurrency?: string      // defaults to requestedCurrency
-}
-
-type CardPaymentResult = {
-  status: 'pending' | 'approved' | 'declined' | 'refunded' | 'aborted'
-  last4?: string
-  brand?: string
-  authorizationCode?: string
-  terminalId?: string
-  companyName?: string
-  companyAddress1?: string
-  companyAddress2?: string
-  companyCity?: string
-  companyCountry?: string          // ISO 3166-1 alpha-2
-  reason?: string
-  receiptUrl?: string
-  refundToken?: string             // present when this card payment was refunded
-}
-
-type SepaPaymentIntent = { paymentIntentId: string; amount: number; requestedCurrency: string; settlementCurrency?: string }
-type SepaPaymentResult = { status: 'pending' | 'verified' | 'aborted' | 'refunded' | 'declined'; postponed: boolean; receivedAt: string; receivedFromIban: string; receiptUrl?: string }
-
-type CertisPaymentIntent = { paymentIntentId: string; amount: number; requestedCurrency: string; settlementCurrency?: string }
-type CertisPaymentResult = { status: 'pending' | 'verified' | 'aborted' | 'refunded' | 'declined'; postponed: boolean; receivedAt: string; receivedFromIban: string; receiptUrl?: string }
-
-type RefundReason = 'customerRequest' | 'duplicate' | 'fraudulent' | 'expiredCharge'
-type TransactionStatus = 'pending' | 'success' | 'cancelled' | 'refunded' | 'failed' | 'actionNeeded'
-
-type RefundIntent = {
-  paymentToken: string             // source payment UUID or original paymentIntentId
-  refundToken?: string             // idempotency token, pass same value on retry
-  reason: RefundReason
-}
-
-type RefundResult = {
-  refundToken?: string
-  status: TransactionStatus
-  refundReason: RefundReason
-  paymentMethod?: PaymentMethod
-  requestedAmount?: number
-  requestedCurrency?: string
-  settlementAmount?: number
-  settlementCurrency?: string
-  fxRate?: number
-  createdAt?: string               // ISO 8601 UTC
-  processedAt?: string             // ISO 8601 UTC
-}
-
-type PaymentMethod = 'CARD' | 'SEPA' | 'CERTIS' | 'CRYPTO'
-type PaymentMethodStatus = 'NOT_STARTED' | 'PENDING' | 'ACTIVE' | 'ATTENTION_NEEDED' | 'ACTION_REQUIRED' | 'BLOCKED'
-
-type AcceptPaymentMethodStatus = { method: PaymentMethod; status: PaymentMethodStatus }
-type AcceptOnboardingStatus = { isOnboarded: boolean; paymentMethods: AcceptPaymentMethodStatus[] }
+Accept.setLogLevel('DEBUG'); // NONE | ERROR | WARN | INFO | DEBUG | VERBOSE
+Accept.setLogger((entry) => Sentry.addBreadcrumb({ message: entry.message }));
+```
 
-type GradientColors = { start: string; end: string }
+Logging defaults to `DEBUG` against sandbox and `NONE` against production. Pass `null` to
+`setLogger` to restore the default Logcat sink.
 
-type AcceptColorTheme = {
-  accent: string                   // #RRGGBB or #AARRGGBB
-  error: string
-  warning: string
-  success: string
-  brandGradientColors?: GradientColors
-  brandSubtleGradientColors?: GradientColors
-}
+### Logout
 
-type AcceptImageTheme = {
-  brandLogo: string                // base64 PNG/JPEG
-  toolbarLogo: string
-  solidLogo: string
-}
+```ts
+await Accept.plugin.logout(); // sign the merchant out of the plugin app
+await Accept.clear(); // clear the local token, device id, cached config, and theme
+```
 
-type AcceptThemeConfiguration = {
-  colors?: AcceptColorTheme
-  images?: AcceptImageTheme
-}
+## Running the example app
 
-// Android-only
-type NfcIndicator = 'DEFAULT' | 'ABOVE' | 'BELOW' | 'FRONT' | 'BEHIND'
-type NfcPosition = { xBias: number; yBias: number }   // 0..1 normalized; omit position for terminal default
-type NfcZone = { indicator: NfcIndicator; position?: NfcPosition }
-type AcceptUiBehavior = {
-  resultScreenDurationSeconds?: number
-  showResultScreen?: boolean
-  nfcZone?: NfcZone
-}
+`example/` is a demo harness mirroring the Accept SDK for Android's own `example` module: one
+control per public API call, and a log pane showing what each one returned.
 
-type KybPrefillData = {
-  businessType?: 'individual' | 'company' | 'nonProfit' | 'governmentEntity'
-  countryCode?: string             // ISO 3166-1 alpha-2
-  registrationNumber?: string
-  vatNumber?: string
-  legalName?: string
-  addressLine1?: string
-  addressLine2?: string
-  city?: string
-  postalCode?: string
-  merchantCategoryCode?: number
-  businessEmail?: string
-  bankAccountIban?: string
-  businessUrl?: string
-  productDescription?: string
-  supportPhone?: string
-}
+```sh
+npm install                       # installs the root package and the example workspace
+cp example/.env.example example/.env.local   # optional: prefill credentials
+npm run android                   # prebuilds and runs on a connected device
 ```
 
-## Documentation
+`.env.local` is gitignored. Leave it out and type the API key and merchant token into the app's
+Credentials fields instead — nothing is persisted either way. Never put a production key in it:
+Expo inlines `EXPO_PUBLIC_*` variables into the bundle at build time.
 
-Full documentation is available at [docs.tapaya.com](https://docs.tapaya.com).
+The example needs a real device with the Accept plugin app installed; an emulator has no card
+reader. Tap **Login** to mint a merchant token and authenticate, then **activateTerminal()** once
+before the first payment.
 
 ## License
 
-Licensed under the [Apache License, Version 2.0](LICENSE).
+Apache-2.0. See [LICENSE](LICENSE) and [NOTICE](NOTICE).