@spare-technologies/spare-link 0.1.0-beta.0

package/src/internal/secure-store-pending-session-store.ts

@@ -0,0 +1,131 @@
+/**
+ * Production `PendingSessionStore` backed by expo-secure-store. Persists a
+ * single in-flight payment session so the SDK can recover after cold start.
+ */
+
+import type { PendingSessionRecord } from '../core/models';
+import type { PendingSessionStore } from '../core/services/pending-session-store';
+import { createLogger } from './logger';
+
+const log = createLogger('SecureStorePendingSessionStore');
+
+const KEYS = {
+  sessionId: 'spare_link_session_id',
+  bankId: 'spare_link_bank_id',
+  authUrl: 'spare_link_auth_url',
+  consentAt: 'spare_link_consent_at',
+  recoveryAttempts: 'spare_link_recovery_attempts',
+  merchantRef: 'spare_link_merchant_ref',
+} as const;
+
+export interface SecureStoreModule {
+  getItemAsync(key: string): Promise<string | null>;
+  setItemAsync(key: string, value: string): Promise<void>;
+  deleteItemAsync(key: string): Promise<void>;
+}
+
+async function defaultLoader(): Promise<SecureStoreModule> {
+  try {
+    return (await import('expo-secure-store')) as unknown as SecureStoreModule;
+  } catch (err) {
+    throw new Error(
+      `SecureStorePendingSessionStore requires 'expo-secure-store' — install it in your app. (${
+        err instanceof Error ? err.message : String(err)
+      })`,
+    );
+  }
+}
+
+export class SecureStorePendingSessionStore implements PendingSessionStore {
+  private secureStore: Promise<SecureStoreModule> | null = null;
+  private readonly loader: () => Promise<SecureStoreModule>;
+  /**
+   * Promise chain serializing every write/clear so a `clear()` racing a
+   * partial `save()` can't leave the store in a half-written state.
+   */
+  private writeQueue: Promise<void> = Promise.resolve();
+
+  /**
+   * @param moduleLoader Optional override returning the secure-store module.
+   *                     Defaults to dynamically importing `expo-secure-store`.
+   *                     Tests inject an in-memory fake.
+   */
+  constructor(moduleLoader: () => Promise<SecureStoreModule> = defaultLoader) {
+    this.loader = moduleLoader;
+  }
+
+  private get module(): Promise<SecureStoreModule> {
+    if (!this.secureStore) this.secureStore = this.loader();
+    return this.secureStore;
+  }
+
+  /** Serializes write operations so save+clear can't interleave. */
+  private enqueueWrite(op: () => Promise<void>): Promise<void> {
+    const next = this.writeQueue.then(op, op);
+    this.writeQueue = next.catch(() => {
+      // Swallow so one failure doesn't poison the queue.
+    });
+    return next;
+  }
+
+  save(record: PendingSessionRecord): Promise<void> {
+    return this.enqueueWrite(async () => {
+      const s = await this.module;
+      await Promise.all([
+        s.setItemAsync(KEYS.sessionId, record.sessionId),
+        s.setItemAsync(KEYS.bankId, record.selectedBankId),
+        s.setItemAsync(KEYS.authUrl, record.authorizationUrl),
+        record.consentAt !== undefined
+          ? s.setItemAsync(KEYS.consentAt, String(record.consentAt))
+          : s.deleteItemAsync(KEYS.consentAt),
+        s.setItemAsync(KEYS.recoveryAttempts, String(record.recoveryAttempts)),
+        record.merchantRef
+          ? s.setItemAsync(KEYS.merchantRef, record.merchantRef)
+          : s.deleteItemAsync(KEYS.merchantRef),
+      ]);
+    });
+  }
+
+  async load(): Promise<PendingSessionRecord | null> {
+    // Wait for any pending writes to settle so we read a consistent snapshot.
+    await this.writeQueue.catch(() => undefined);
+    const s = await this.module;
+    const [sessionId, bankId, authUrl, consentAtRaw, attemptsRaw, merchantRef] = await Promise.all([
+      s.getItemAsync(KEYS.sessionId),
+      s.getItemAsync(KEYS.bankId),
+      s.getItemAsync(KEYS.authUrl),
+      s.getItemAsync(KEYS.consentAt),
+      s.getItemAsync(KEYS.recoveryAttempts),
+      s.getItemAsync(KEYS.merchantRef),
+    ]);
+    if (!sessionId || !bankId || !authUrl) {
+      log.fine('load: no pending session found');
+      return null;
+    }
+    const consentAt = consentAtRaw ? Number(consentAtRaw) : undefined;
+    const recoveryAttempts = attemptsRaw ? Number(attemptsRaw) : 0;
+    const record: PendingSessionRecord = {
+      sessionId,
+      selectedBankId: bankId,
+      authorizationUrl: authUrl,
+      recoveryAttempts: Number.isFinite(recoveryAttempts) ? recoveryAttempts : 0,
+    };
+    if (consentAt !== undefined && Number.isFinite(consentAt)) record.consentAt = consentAt;
+    if (merchantRef) record.merchantRef = merchantRef;
+    return record;
+  }
+
+  clear(): Promise<void> {
+    return this.enqueueWrite(async () => {
+      const s = await this.module;
+      await Promise.all([
+        s.deleteItemAsync(KEYS.sessionId),
+        s.deleteItemAsync(KEYS.bankId),
+        s.deleteItemAsync(KEYS.authUrl),
+        s.deleteItemAsync(KEYS.consentAt),
+        s.deleteItemAsync(KEYS.recoveryAttempts),
+        s.deleteItemAsync(KEYS.merchantRef),
+      ]);
+    });
+  }
+}

package/src/internal/telemetry-collector.ts

@@ -0,0 +1,90 @@
+/**
+ * Best-effort device + geolocation telemetry collector. Each call site catches
+ * runtime failures so a permission denial or missing native module degrades
+ * to a partial payload instead of throwing.
+ */
+import { Platform } from 'react-native';
+import { SDK_VERSION } from '../version';
+import { createLogger } from './logger';
+
+const log = createLogger('TelemetryCollector');
+
+const LOCATION_TIMEOUT_MS = 5_000;
+
+interface DeviceLike {
+  modelName?: string | null;
+  osVersion?: string | null;
+}
+
+interface LocationLike {
+  requestForegroundPermissionsAsync(): Promise<{ status: 'granted' | 'denied' | 'undetermined' }>;
+  getCurrentPositionAsync(opts: { accuracy?: number }): Promise<{
+    coords: { latitude: number; longitude: number; accuracy: number | null };
+  }>;
+}
+
+async function loadDevice(): Promise<DeviceLike | null> {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    return require('expo-device') as DeviceLike;
+  } catch {
+    return null;
+  }
+}
+
+async function loadLocation(): Promise<LocationLike | null> {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    return require('expo-location') as LocationLike;
+  } catch {
+    return null;
+  }
+}
+
+export async function collectTelemetry(): Promise<Record<string, unknown>> {
+  log.fine('collect: gathering device telemetry');
+  const [deviceMod, locationMod] = await Promise.all([loadDevice(), loadLocation()]);
+
+  const payload: Record<string, unknown> = {
+    platform: 'react_native',
+    sdk_version: SDK_VERSION,
+    os: Platform.OS,
+  };
+
+  const model = deviceMod?.modelName ?? null;
+  const osVersion = deviceMod?.osVersion ?? null;
+  if (model && osVersion) {
+    payload.device_fingerprint = `${model}_${osVersion}`;
+  }
+
+  if (locationMod) {
+    try {
+      const permission = await locationMod.requestForegroundPermissionsAsync();
+      if (permission.status === 'granted') {
+        const position = await Promise.race<{
+          coords: { latitude: number; longitude: number; accuracy: number | null };
+        } | null>([
+          locationMod.getCurrentPositionAsync({ accuracy: 3 }),
+          new Promise((resolve) => setTimeout(() => resolve(null), LOCATION_TIMEOUT_MS)),
+        ]);
+        if (position) {
+          payload.geolocation = {
+            latitude: position.coords.latitude,
+            longitude: position.coords.longitude,
+            accuracy_m: position.coords.accuracy,
+          };
+        } else {
+          payload.geolocation = { unavailable: 'timeout' };
+        }
+      } else {
+        payload.geolocation = { unavailable: 'permission_denied' };
+      }
+    } catch (e) {
+      log.warning(`collect: geolocation failed — ${e instanceof Error ? e.message : String(e)}`);
+      payload.geolocation = { unavailable: 'error' };
+    }
+  }
+
+  log.fine(`collect: payload keys=${Object.keys(payload).join(',')}`);
+  return payload;
+}

package/src/public/constants.ts

@@ -0,0 +1,14 @@
+/**
+ * Max non-terminal `resumeIfNeeded` recovery attempts before the SDK gives up
+ * and resolves the flow as failed with code `recovery_exhausted`.
+ */
+export const kMaxRecoveryAttempts = 3 as const;
+
+/** Default per-request HTTP timeout in milliseconds (15s). */
+export const DEFAULT_REQUEST_TIMEOUT_MS = 15_000 as const;
+
+/** How long the SDK waits for a bank callback before auto-failing with `session_timeout`. */
+export const DEFAULT_AWAITING_CALLBACK_TIMEOUT_MS = 5 * 60 * 1000;
+
+/** Polling interval while the flow is in awaitingCallback (status endpoint). */
+export const DEFAULT_AWAITING_CALLBACK_POLL_MS = 10_000;

package/src/public/index.ts

@@ -0,0 +1,80 @@
+export {
+  type PaymentEnvironment,
+  type SpareApiTenant,
+  type SpareLinkConfig,
+  type SpareLinkResumeConfig,
+  defaultBaseUrlFor,
+  tenantCountryCode,
+  resolvedBaseUrl,
+  resolvedResumeBaseUrl,
+  assertValidConfig,
+} from './spare-link-config';
+
+export {
+  type SpareLinkEvent,
+  type SpareLinkEventType,
+  type SpareLinkInitialized,
+  type SpareLinkSessionLoaded,
+  type SpareLinkConsentStarted,
+  type SpareLinkRedirectToBank,
+  type SpareLinkBankCallbackReceived,
+  type SpareLinkSucceeded,
+  type SpareLinkFailed,
+  type SpareLinkCancelled,
+  type SpareLinkAbandoned,
+  SPARE_LINK_EVENT_TYPES,
+  isSpareLinkEvent,
+  SpareLinkEvents,
+} from './spare-link-event';
+
+export {
+  type PaymentStatus,
+  type PaymentResult,
+  type PaymentSuccess,
+  type PaymentCancelled,
+  type PaymentFailed,
+  type PaymentAbandoned,
+  paymentSuccess,
+  paymentCancelled,
+  paymentFailed,
+  paymentAbandoned,
+} from './payment-result';
+
+export type {
+  SpareLinkCallbacks,
+  SpareLinkSuccessCallback,
+  SpareLinkExitCallback,
+  SpareLinkEventCallback,
+} from './spare-link-callbacks';
+
+export type {
+  RecoveryResult,
+  NoRecoveryReason,
+  NoRecoveryNeeded,
+  SessionRecovered,
+  RecoveryAwaitingUser,
+} from './recovery-result';
+export {
+  isSessionRecovered,
+  isNoRecoveryNeeded,
+  isRecoveryAwaitingUser,
+} from './recovery-result';
+
+export { SpareLinkSession } from './spare-link-session';
+export { SpareLink, type SpareLinkOptions } from './spare-link-instance';
+
+export {
+  kMaxRecoveryAttempts,
+  DEFAULT_REQUEST_TIMEOUT_MS,
+  DEFAULT_AWAITING_CALLBACK_TIMEOUT_MS,
+  DEFAULT_AWAITING_CALLBACK_POLL_MS,
+} from './constants';
+
+export {
+  configureSpareLinkLogging,
+  createLogger,
+  type SpareLinkLogLevel,
+  type SpareLinkLogRecord,
+  type SpareLinkLogSink,
+  type SpareLinkLogger,
+} from '../internal/logger';

package/src/public/payment-result.ts

@@ -0,0 +1,61 @@
+/**
+ * Terminal outcome of a payment flow — narrow on the `status` field.
+ */
+export type PaymentStatus = 'success' | 'cancelled' | 'failed' | 'abandoned';
+
+interface PaymentResultBase {
+  status: PaymentStatus;
+  /** The `link_token` JWS that identifies this payment flow. Mirrors Flutter's `linkToken`. */
+  linkToken: string;
+  bankId?: string;
+  linkSessionId?: string;
+  message?: string;
+  errorCode?: string;
+  resolvedAtMs?: number;
+}
+
+/** Payment completed at the bank. `exchangeCode` may be null when recovered
+ * via status polling (the bank delivered the code straight to the merchant
+ * backend, bypassing the SDK). */
+export interface PaymentSuccess extends PaymentResultBase {
+  status: 'success';
+  exchangeCode?: string;
+  merchantRef?: string;
+  /** API payment type string (e.g. `FixedPeriodicSchedule`), when available. Mirrors Flutter's `paymentType`. */
+  paymentType?: string;
+}
+
+export interface PaymentCancelled extends PaymentResultBase {
+  status: 'cancelled';
+}
+
+/** Payment failed. Always has an `errorCode` so merchants can map to UI copy. */
+export interface PaymentFailed extends PaymentResultBase {
+  status: 'failed';
+  errorCode: string;
+}
+
+/** Flow abandoned mid-flight (app killed, host removed the SDK navigator). */
+export interface PaymentAbandoned extends PaymentResultBase {
+  status: 'abandoned';
+}
+
+export type PaymentResult = PaymentSuccess | PaymentCancelled | PaymentFailed | PaymentAbandoned;
+
+// ---- Constructor helpers ---------------------------------------------------
+
+export function paymentSuccess(args: Omit<PaymentSuccess, 'status'>): PaymentSuccess {
+  return { status: 'success', ...args };
+}
+
+export function paymentCancelled(args: Omit<PaymentCancelled, 'status'>): PaymentCancelled {
+  return { status: 'cancelled', ...args };
+}
+
+export function paymentFailed(args: Omit<PaymentFailed, 'status'>): PaymentFailed {
+  return { status: 'failed', ...args };
+}
+
+export function paymentAbandoned(args: Omit<PaymentAbandoned, 'status'>): PaymentAbandoned {
+  return { status: 'abandoned', ...args };
+}

package/src/public/recovery-result.ts

@@ -0,0 +1,49 @@
+import type { PaymentResult } from './payment-result';
+
+/**
+ * Why {@link SpareLink.resumeIfNeeded} did not recover a terminal session.
+ * Mirrors Flutter's `NoRecoveryReason`.
+ */
+export type NoRecoveryReason = 'noPendingSession' | 'flowAlreadyActive' | 'persistenceUnavailable';
+
+/**
+ * Outcome of {@link SpareLink.resumeIfNeeded}.
+ *
+ * Discriminated union aligned with Flutter's sealed `RecoveryResult`.
+ */
+export type RecoveryResult = NoRecoveryNeeded | SessionRecovered | RecoveryAwaitingUser;
+
+/** No pending session was recovered. */
+export interface NoRecoveryNeeded {
+  readonly kind: 'none';
+  readonly reason: NoRecoveryReason;
+}
+
+/** A pending session was recovered to a terminal {@link PaymentResult}. */
+export interface SessionRecovered {
+  readonly kind: 'recovered';
+  readonly result: PaymentResult;
+}
+
+/**
+ * A pending session is non-terminal and the SDK opened its recovery UI —
+ * the integrator should treat this as in-progress, not "nothing happened".
+ * The terminal outcome arrives later via `SpareLink.events` /
+ * `spareLink.emitTerminal`, not as a second `resumeIfNeeded` resolution.
+ */
+export interface RecoveryAwaitingUser {
+  readonly kind: 'awaitingUser';
+  readonly linkToken: string;
+}
+
+export function isSessionRecovered(r: RecoveryResult): r is SessionRecovered {
+  return r.kind === 'recovered';
+}
+
+export function isNoRecoveryNeeded(r: RecoveryResult): r is NoRecoveryNeeded {
+  return r.kind === 'none';
+}
+
+export function isRecoveryAwaitingUser(r: RecoveryResult): r is RecoveryAwaitingUser {
+  return r.kind === 'awaitingUser';
+}

package/src/public/spare-link-callbacks.ts

@@ -0,0 +1,20 @@
+import type { PaymentResult } from './payment-result';
+import type { SpareLinkEventType } from './spare-link-event';
+
+/** Called on successful payment. Both args may be null when recovered. */
+export type SpareLinkSuccessCallback = (
+  exchangeCode: string | undefined,
+  linkSessionId: string | undefined,
+) => void;
+
+/** Called when the flow resolves to any terminal state (success or failure). */
+export type SpareLinkExitCallback = (result: PaymentResult) => void;
+
+/** Called for intermediate lifecycle events (string tag). Best-effort — exceptions are caught. */
+export type SpareLinkEventCallback = (event: SpareLinkEventType) => void;
+
+export interface SpareLinkCallbacks {
+  onSuccess?: SpareLinkSuccessCallback;
+  onExit?: SpareLinkExitCallback;
+  onEvent?: SpareLinkEventCallback;
+}

package/src/public/spare-link-config.ts

@@ -0,0 +1,87 @@
+/**
+ * Deployment environment for the Spare Link API.
+ *
+ * Each value maps to a default base URL
+ * the SDK will hit unless `baseUrl` is overridden in {@link SpareLinkConfig}.
+ */
+export type PaymentEnvironment = 'sandbox' | 'production';
+
+const DEFAULT_BASE_URLS: Record<PaymentEnvironment, string> = {
+  sandbox: 'https://api.sandbox.tryspare.ae',
+  production: 'https://api.tryspare.ae',
+};
+
+export function defaultBaseUrlFor(env: PaymentEnvironment): string {
+  return DEFAULT_BASE_URLS[env];
+}
+
+/** Spare API tenant — one country per tenant. */
+export type SpareApiTenant = 'ksa' | 'uae' | 'bah';
+
+const TENANT_COUNTRY_CODES: Record<SpareApiTenant, string> = {
+  ksa: 'KSA',
+  uae: 'UAE',
+  bah: 'BAH',
+};
+
+export function tenantCountryCode(t: SpareApiTenant): string {
+  return TENANT_COUNTRY_CODES[t];
+}
+
+/** Configuration to start a Spare Link payment flow. */
+export interface SpareLinkConfig {
+  /** One-time link token minted by the merchant backend via POST /link/token/payment. */
+  linkToken: string;
+
+  /** Target environment (sandbox vs production). */
+  environment: PaymentEnvironment;
+
+  /** Tenant (country). */
+  tenant: SpareApiTenant;
+
+  /**
+   * Override the base URL. Set only for local dev (e.g. `http://localhost:4000`)
+   * — production should rely on the environment-derived default.
+   */
+  baseUrl?: string;
+
+  /**
+   * Inject a custom fetch implementation for advanced cases (cert pinning,
+   * request logging). Defaults to `globalThis.fetch`.
+   */
+  fetch?: typeof fetch;
+
+  /** Per-request timeout in milliseconds. Defaults to 15000. */
+  requestTimeoutMs?: number;
+}
+
+/** Resolved base URL: explicit `baseUrl` if provided, else the environment default. */
+export function resolvedBaseUrl(config: SpareLinkConfig): string {
+  return config.baseUrl ?? defaultBaseUrlFor(config.environment);
+}
+
+/**
+ * Recovery config — like {@link SpareLinkConfig} but without `linkToken`
+ * (read from the persisted record).
+ */
+export interface SpareLinkResumeConfig {
+  environment: PaymentEnvironment;
+  tenant: SpareApiTenant;
+  baseUrl?: string;
+  fetch?: typeof fetch;
+  requestTimeoutMs?: number;
+}
+
+export function resolvedResumeBaseUrl(config: SpareLinkResumeConfig): string {
+  return config.baseUrl ?? defaultBaseUrlFor(config.environment);
+}
+
+/** Throws if a SpareLinkConfig is structurally invalid. */
+export function assertValidConfig(config: SpareLinkConfig): void {
+  if (!config.linkToken) {
+    throw new Error('SpareLinkConfig: linkToken must not be empty');
+  }
+  if (config.baseUrl && !/^https?:\/\//.test(config.baseUrl)) {
+    throw new Error('SpareLinkConfig: baseUrl must start with http:// or https://');
+  }
+}

package/src/public/spare-link-event.ts

@@ -0,0 +1,146 @@
+import type { PaymentResult } from './payment-result';
+
+/**
+ * Lifecycle events emitted on {@link SpareLink.events}.
+ *
+ * This is a discriminated union (TypeScript's equivalent to Dart sealed classes).
+ * Use a switch on the `type` field for exhaustive handling:
+ *
+ * ```ts
+ * spareLink.events.subscribe((event) => {
+ *   switch (event.type) {
+ *     case 'initialized':
+ *       console.log('Started flow for', event.linkToken);
+ *       break;
+ *     case 'sessionLoaded':
+ *       console.log('Session loaded', event.linkSessionId);
+ *       break;
+ *     case 'succeeded':
+ *       console.log('Payment succeeded', event.result.exchangeCode);
+ *       break;
+ *     // ...
+ *   }
+ * });
+ * ```
+ */
+export type SpareLinkEvent =
+  | SpareLinkInitialized
+  | SpareLinkSessionLoaded
+  | SpareLinkConsentStarted
+  | SpareLinkRedirectToBank
+  | SpareLinkBankCallbackReceived
+  | SpareLinkSucceeded
+  | SpareLinkFailed
+  | SpareLinkCancelled
+  | SpareLinkAbandoned;
+
+/** The SDK has started a payment flow. */
+export interface SpareLinkInitialized {
+  readonly type: 'initialized';
+  readonly linkToken: string;
+}
+
+/** The payment session was loaded from the server. */
+export interface SpareLinkSessionLoaded {
+  readonly type: 'sessionLoaded';
+  readonly linkToken: string;
+  /** Server-assigned link session ID when available from the API. */
+  readonly linkSessionId?: string;
+}
+
+/** The user confirmed consent and a consent request was submitted. */
+export interface SpareLinkConsentStarted {
+  readonly type: 'consentStarted';
+  readonly linkToken: string;
+}
+
+/** The user is being redirected to their bank's authorization page. */
+export interface SpareLinkRedirectToBank {
+  readonly type: 'redirectToBank';
+  readonly linkToken: string;
+}
+
+/** The bank has redirected back with a callback URI. */
+export interface SpareLinkBankCallbackReceived {
+  readonly type: 'bankCallbackReceived';
+  readonly linkToken: string;
+}
+
+/** The payment completed successfully and the flow is about to resolve. */
+export interface SpareLinkSucceeded {
+  readonly type: 'succeeded';
+  readonly result: PaymentResult;
+}
+
+/** The payment failed and the flow is about to resolve. */
+export interface SpareLinkFailed {
+  readonly type: 'failed';
+  readonly result: PaymentResult;
+}
+
+/** The user cancelled the payment and the flow is about to resolve. */
+export interface SpareLinkCancelled {
+  readonly type: 'cancelled';
+  readonly result: PaymentResult;
+}
+
+/** The flow was abandoned without an explicit user action. */
+export interface SpareLinkAbandoned {
+  readonly type: 'abandoned';
+  readonly result: PaymentResult;
+}
+
+/** All possible event type strings for type narrowing. */
+export const SPARE_LINK_EVENT_TYPES = [
+  'initialized',
+  'sessionLoaded',
+  'consentStarted',
+  'redirectToBank',
+  'bankCallbackReceived',
+  'succeeded',
+  'failed',
+  'cancelled',
+  'abandoned',
+] as const;
+
+export type SpareLinkEventType = (typeof SPARE_LINK_EVENT_TYPES)[number];
+
+/** Type guard for SpareLinkEvent. */
+export function isSpareLinkEvent(value: unknown): value is SpareLinkEvent {
+  if (typeof value !== 'object' || value === null) return false;
+  const type = (value as { type?: unknown }).type;
+  return typeof type === 'string' && SPARE_LINK_EVENT_TYPES.includes(type as SpareLinkEventType);
+}
+
+/** Factory functions for creating events (internal use). */
+export const SpareLinkEvents = {
+  initialized(linkToken: string): SpareLinkInitialized {
+    return { type: 'initialized', linkToken };
+  },
+  sessionLoaded(linkToken: string, linkSessionId?: string): SpareLinkSessionLoaded {
+    return linkSessionId
+      ? { type: 'sessionLoaded', linkToken, linkSessionId }
+      : { type: 'sessionLoaded', linkToken };
+  },
+  consentStarted(linkToken: string): SpareLinkConsentStarted {
+    return { type: 'consentStarted', linkToken };
+  },
+  redirectToBank(linkToken: string): SpareLinkRedirectToBank {
+    return { type: 'redirectToBank', linkToken };
+  },
+  bankCallbackReceived(linkToken: string): SpareLinkBankCallbackReceived {
+    return { type: 'bankCallbackReceived', linkToken };
+  },
+  succeeded(result: PaymentResult): SpareLinkSucceeded {
+    return { type: 'succeeded', result };
+  },
+  failed(result: PaymentResult): SpareLinkFailed {
+    return { type: 'failed', result };
+  },
+  cancelled(result: PaymentResult): SpareLinkCancelled {
+    return { type: 'cancelled', result };
+  },
+  abandoned(result: PaymentResult): SpareLinkAbandoned {
+    return { type: 'abandoned', result };
+  },
+} as const;