@munchi_oy/payments 1.4.9 → 1.5.0

package/src/strategies/VivaAppToAppStrategy.ts

@@ -0,0 +1,810 @@
+import {
+  type CreateTerminalPaymentDto,
+  FeeType,
+  PaymentFailureCode,
+  PaymentMethod,
+  PaymentProvider,
+  VivaApi,
+  type VivaAppToAppInitResponseDto,
+  type TransactionDto,
+  type TransactionDtoFees,
+  PaymentApi,
+} from "@munchi_oy/core";
+import type { AxiosInstance } from "axios";
+
+import { PaymentErrorCode, PaymentSDKError } from "../error";
+import {
+  PaymentInteractionState,
+  type PaymentRequest,
+  type PaymentResult,
+  type PaymentTerminalConfig,
+  type RefundRequest,
+  SdkPaymentStatus,
+  type VivaOptions,
+} from "../types/payment";
+import type { AppToAppConfig } from "../types/sdk";
+import { normalizeTimestamp, parseInteger } from "../utils/parsing";
+import {
+  type IPaymentStrategy,
+  StrategyExecutionMode,
+} from "./IPaymentStrategy";
+
+const VIVA_APP_TO_APP_BASE_URL = "vivapayclient://pay/v1";
+const VIVA_ACTION_ABORT = "abort";
+const VIVA_ACTION_CANCEL = "cancel";
+const VIVA_ACTION_SALE = "sale";
+const VIVA_ACTION_TRANSACTION_DETAILS = "transactionDetails";
+const VIVA_TRANSACTION_DETAILS_TIMEOUT_MS = 4000;
+const EDENRED_BIN_PREFIX = "534287";
+const WOLT_BENEFIT_BIN_PREFIX = "493591";
+const CREDIT_KEYWORDS = ["CREDIT", "PREPAID", "CORPORATE"];
+
+type VivaLaunchParams = Record<string, boolean | number | string | undefined>;
+type VivaCallbackParams = Record<string, string>;
+type PaymentReferenceLookupRequest = {
+  orderId: string;
+  provider: PaymentProvider;
+  transactionId: string;
+};
+type PaymentReferenceResponse = {
+  originalTransactionId: string;
+  references: object | null;
+};
+type PaymentReferenceContext = {
+  originalTransactionId?: string;
+  receiptNumber?: string;
+  referenceCode?: string;
+  shortReferenceCode?: string;
+  terminalId?: string;
+};
+
+export class VivaAppToAppStrategy implements IPaymentStrategy {
+  private api: VivaApi;
+  private paymentApi: PaymentApi;
+  private abortController: AbortController | null = null;
+  private currentClientTransactionId: string | null = null;
+  private currentIsvClientTransactionId: string | null = null;
+  private currentCurrency: PaymentRequest["currency"] | null = null;
+  private currentOrderRef: string | null = null;
+  private currentSourceTerminalId: string | null = null;
+  private latestResult: PaymentResult | null = null;
+  private paymentApiWithReference: PaymentApi & {
+    getPaymentReference: (
+      request: PaymentReferenceLookupRequest,
+    ) => Promise<{ data: PaymentReferenceResponse }>;
+  };
+  private wasCancelled = false;
+
+  constructor(
+    axios: AxiosInstance,
+    _messaging: unknown,
+    private config: PaymentTerminalConfig,
+    private appToAppConfig: AppToAppConfig,
+  ) {
+    this.api = new VivaApi(undefined, "", axios);
+    this.paymentApi = new PaymentApi(undefined, "", axios);
+    this.paymentApiWithReference = this.paymentApi as PaymentApi & {
+      getPaymentReference: (
+        request: PaymentReferenceLookupRequest,
+      ) => Promise<{ data: PaymentReferenceResponse }>;
+    };
+  }
+
+  getExecutionMode() {
+    return StrategyExecutionMode.CallbackDriven;
+  }
+
+  async processPayment(
+    request: PaymentRequest,
+    onStateChange: (
+      state: PaymentInteractionState,
+      detail?: { sessionId?: string },
+    ) => void,
+  ): Promise<PaymentResult> {
+    if (!this.appToAppConfig.enabled) {
+      throw new PaymentSDKError(
+        PaymentErrorCode.STRATEGY_ERROR,
+        "Viva app-to-app is not enabled",
+      );
+    }
+
+    onStateChange(PaymentInteractionState.CONNECTING);
+
+    try {
+      const { data } = await this.api.createVivaAppToAppPayment(
+        this.buildCreatePaymentPayload(request),
+      );
+
+      return await this.runAction(
+        VIVA_ACTION_SALE,
+        this.buildLaunchParams(data),
+        request,
+        onStateChange,
+      );
+    } catch (error) {
+      throw new PaymentSDKError(
+        PaymentErrorCode.NETWORK_ERROR,
+        "Failed to create Viva app-to-app payment",
+        error,
+      );
+    }
+  }
+
+  async cancelTransaction(
+    _onStateChange: (state: PaymentInteractionState) => void,
+  ): Promise<boolean> {
+    if (!this.currentClientTransactionId) {
+      return false;
+    }
+
+    const transactionDetailsResult = await this.lookupTransactionDetails();
+    if (transactionDetailsResult) {
+      this.latestResult = transactionDetailsResult;
+      this.wasCancelled =
+        transactionDetailsResult.status === SdkPaymentStatus.CANCELLED;
+      this.abortController?.abort();
+      return true;
+    }
+
+    try {
+      await this.appToAppConfig.adapter.openUrl(
+        this.buildActionUrl(VIVA_ACTION_ABORT, {}),
+      );
+    } catch (error) {
+      this.abortController?.abort();
+      throw new PaymentSDKError(
+        PaymentErrorCode.NETWORK_ERROR,
+        "Failed to launch Viva abort flow",
+        error,
+      );
+    }
+
+    this.wasCancelled = true;
+    this.abortController?.abort();
+    return true;
+  }
+
+  async refundTransaction(
+    request: RefundRequest,
+    onStateChange: (
+      state: PaymentInteractionState,
+      detail?: { sessionId?: string },
+    ) => void,
+  ): Promise<PaymentResult> {
+    onStateChange(PaymentInteractionState.CONNECTING);
+
+    const reference = await this.fetchPaymentReference(request);
+    const launchParams = this.buildRefundLaunchParams(request, reference);
+    return this.runAction(
+      VIVA_ACTION_CANCEL,
+      launchParams,
+      request,
+      onStateChange,
+    );
+  }
+
+  async verifyFinalStatus(
+    _request: PaymentRequest,
+    sessionId: string,
+  ): Promise<PaymentResult> {
+    if (this.latestResult) {
+      return this.latestResult;
+    }
+
+    if (this.wasCancelled) {
+      return {
+        success: false,
+        status: SdkPaymentStatus.CANCELLED,
+        orderId: this.currentOrderRef ?? sessionId,
+        errorCode: PaymentFailureCode.PaymentCancelledByUser,
+        errorMessage: "Transaction was cancelled",
+        transactionId: sessionId,
+      };
+    }
+
+    return {
+      success: false,
+      status: SdkPaymentStatus.PENDING,
+      orderId: this.currentOrderRef ?? sessionId,
+      transactionId: sessionId,
+    };
+  }
+
+  abort(): void {
+    this.abortController?.abort();
+  }
+
+  private async runAction(
+    action: string,
+    launchParams: Record<string, string>,
+    request: PaymentRequest | RefundRequest,
+    onStateChange: (
+      state: PaymentInteractionState,
+      detail?: { sessionId?: string },
+    ) => void,
+  ): Promise<PaymentResult> {
+    if (!this.appToAppConfig.enabled) {
+      throw new PaymentSDKError(
+        PaymentErrorCode.STRATEGY_ERROR,
+        "Viva app-to-app is not enabled",
+      );
+    }
+
+    this.abortController = new AbortController();
+    this.latestResult = null;
+    this.wasCancelled = false;
+    this.currentCurrency = request.currency;
+    this.currentOrderRef = request.orderRef;
+    this.currentSourceTerminalId =
+      launchParams.sourceTerminalId ?? launchParams.tid ?? null;
+
+    this.currentClientTransactionId = launchParams.clientTransactionId ?? null;
+    this.currentIsvClientTransactionId =
+      launchParams.ISV_clientTransactionId ?? null;
+    const detail = this.currentClientTransactionId
+      ? { sessionId: this.currentClientTransactionId }
+      : undefined;
+
+    return new Promise<PaymentResult>((resolve, reject) => {
+      const cleanup = (
+        unsubscribe: (() => void) | undefined,
+        onAbort: () => void,
+      ) => {
+        unsubscribe?.();
+        this.abortController?.signal.removeEventListener("abort", onAbort);
+      };
+
+      const onAbort = () => {
+        cleanup(unsubscribe, onAbort);
+        reject(new Error("Aborted"));
+      };
+
+      const unsubscribe = this.appToAppConfig.adapter.subscribe(
+        (callbackUrl) => {
+          if (this.abortController?.signal.aborted) {
+            return;
+          }
+
+          const parsed = this.parseCallbackUrl(callbackUrl);
+          if (!parsed) {
+            return;
+          }
+
+          if (!this.matchesKnownTransactionId(parsed.rawParams)) {
+            return;
+          }
+
+          this.latestResult = parsed.result;
+          this.wasCancelled =
+            parsed.result.status === SdkPaymentStatus.CANCELLED;
+          this.currentClientTransactionId = null;
+          this.currentIsvClientTransactionId = null;
+          this.currentCurrency = null;
+          this.currentOrderRef = null;
+          this.currentSourceTerminalId = null;
+          cleanup(unsubscribe, onAbort);
+          resolve(parsed.result);
+        },
+      );
+
+      this.abortController?.signal.addEventListener("abort", onAbort);
+      onStateChange(PaymentInteractionState.REQUIRES_INPUT, detail);
+
+      this.appToAppConfig.adapter
+        .openUrl(this.buildActionUrl(action, launchParams))
+        .then(() => {
+          if (this.abortController?.signal.aborted) {
+            return;
+          }
+        })
+        .catch((error) => {
+          cleanup(unsubscribe, onAbort);
+          this.currentClientTransactionId = null;
+          this.currentIsvClientTransactionId = null;
+          this.currentCurrency = null;
+          this.currentOrderRef = null;
+          this.currentSourceTerminalId = null;
+          reject(
+            new PaymentSDKError(
+              PaymentErrorCode.NETWORK_ERROR,
+              "Failed to launch Viva app",
+              error,
+            ),
+          );
+        });
+    });
+  }
+
+  private buildCreatePaymentPayload(
+    request: PaymentRequest,
+  ): CreateTerminalPaymentDto {
+    const vivaOptions = (request.options ?? {}) as VivaOptions;
+    const payload: CreateTerminalPaymentDto = {
+      amount: request.amountCents,
+      referenceId: request.orderRef,
+      businessId: Number(this.config.storeId),
+      currency: request.currency,
+      displayId: request.displayId,
+      showReceipt: true,
+      showTransactionResult: true,
+    };
+
+    if (vivaOptions.tipAmount !== undefined) {
+      payload.tipAmount = vivaOptions.tipAmount;
+    }
+
+    return payload;
+  }
+
+  private buildLaunchParams(
+    payload: VivaLaunchParams | VivaAppToAppInitResponseDto,
+  ): Record<string, string> {
+    const params: Record<string, string> = {};
+
+    Object.entries(payload).forEach(([key, value]) => {
+      if (value !== undefined) {
+        params[key] = String(value);
+      }
+    });
+
+    return params;
+  }
+
+  private buildRefundLaunchParams(
+    request: RefundRequest,
+    reference?: PaymentReferenceContext,
+  ): Record<string, string> {
+    const vivaOptions = (request.options ?? {}) as VivaOptions;
+    const originalTransactionId =
+      reference?.originalTransactionId?.trim() ||
+      request.originalTransactionId.trim();
+    const params: Record<string, string> = {
+      amount: String(request.amountCents),
+      clientTransactionId: originalTransactionId,
+      show_receipt: "true",
+      show_transaction_result: "true",
+    };
+
+    if (vivaOptions.sourceCode) {
+      params.sourceCode = vivaOptions.sourceCode;
+    }
+
+    if (reference?.referenceCode) {
+      params.orderCode = reference.referenceCode;
+    }
+
+    if (reference?.shortReferenceCode) {
+      params.shortOrderCode = reference.shortReferenceCode;
+    }
+
+    if (reference?.receiptNumber) {
+      params.referenceNumber = reference.receiptNumber;
+    }
+
+    if (reference?.terminalId) {
+      params.tid = reference.terminalId;
+    }
+
+    if (
+      reference?.referenceCode ||
+      reference?.shortReferenceCode ||
+      reference?.receiptNumber
+    ) {
+      return params;
+    }
+
+    const originalId = originalTransactionId;
+    if (/^\d+$/.test(originalId)) {
+      if (originalId.length === 16) {
+        params.orderCode = originalId;
+      } else if (originalId.length === 10) {
+        params.shortOrderCode = originalId;
+      } else {
+        params.referenceNumber = originalId;
+      }
+    }
+
+    return params;
+  }
+
+  private async fetchPaymentReference(
+    request: RefundRequest,
+  ): Promise<PaymentReferenceContext | undefined> {
+    try {
+      const { data } = await this.paymentApiWithReference.getPaymentReference({
+        orderId: request.orderRef,
+        provider: PaymentProvider.Viva,
+        transactionId: request.originalTransactionId,
+      });
+
+      return this.extractPaymentReferenceContext(data);
+    } catch {
+      return undefined;
+    }
+  }
+
+  private extractPaymentReferenceContext(
+    response?: PaymentReferenceResponse,
+  ): PaymentReferenceContext | undefined {
+    if (!response) {
+      return undefined;
+    }
+
+    const references = response.references;
+    if (!references || typeof references !== "object" || Array.isArray(references)) {
+      return {
+        originalTransactionId: response.originalTransactionId,
+      };
+    }
+
+    const context = references as Record<string, unknown>;
+    const paymentReferenceContext: PaymentReferenceContext = {
+      originalTransactionId:
+        this.readReferenceValue(context.originalTransactionId) ??
+        this.readReferenceValue(context.clientTransactionId) ??
+        response.originalTransactionId,
+    };
+    const receiptNumber =
+      this.readReferenceValue(context.receiptNumber) ??
+      this.readReferenceValue(context.referenceNumber);
+    const referenceCode =
+      this.readReferenceValue(context.referenceCode) ??
+      this.readReferenceValue(context.orderCode);
+    const shortReferenceCode = this.readReferenceValue(
+      context.shortReferenceCode,
+    ) ?? this.readReferenceValue(context.shortOrderCode);
+    const terminalId =
+      this.readReferenceValue(context.terminalId) ??
+      this.readReferenceValue(context.tid);
+
+    if (receiptNumber) {
+      paymentReferenceContext.receiptNumber = receiptNumber;
+    }
+
+    if (referenceCode) {
+      paymentReferenceContext.referenceCode = referenceCode;
+    }
+
+    if (shortReferenceCode) {
+      paymentReferenceContext.shortReferenceCode = shortReferenceCode;
+    }
+
+    if (terminalId) {
+      paymentReferenceContext.terminalId = terminalId;
+    }
+
+    return paymentReferenceContext;
+  }
+
+  private readReferenceValue(value: unknown): string | undefined {
+    if (typeof value !== "string") {
+      return undefined;
+    }
+
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+  }
+
+  private buildActionUrl(
+    action: string,
+    params: Record<string, string>,
+  ): string {
+    const query = new URLSearchParams({
+      action,
+      appId: this.appToAppConfig.appId,
+      callback: this.appToAppConfig.callbackUrl,
+    });
+
+    Object.entries(params).forEach(([key, value]) => {
+      query.set(key, value);
+    });
+
+    return `${VIVA_APP_TO_APP_BASE_URL}?${query.toString()}`;
+  }
+
+  private parseCallbackUrl(
+    callbackUrl: string,
+  ): { rawParams: Record<string, string>; result: PaymentResult } | null {
+    if (!this.matchesCallbackBase(callbackUrl)) {
+      return null;
+    }
+
+    const parsed = new URL(callbackUrl);
+    const rawParams = Object.fromEntries(parsed.searchParams.entries());
+    const isSuccess = this.isSuccessfulCallback(rawParams);
+    const isCancelled = this.isCancelledCallback(rawParams);
+    const errorCode = this.resolveFailureCode(rawParams, isCancelled);
+
+    const result: PaymentResult = {
+      success: isSuccess,
+      status: isSuccess
+        ? SdkPaymentStatus.SUCCESS
+        : isCancelled
+          ? SdkPaymentStatus.CANCELLED
+          : SdkPaymentStatus.FAILED,
+      orderId:
+        this.currentOrderRef ?? rawParams.clientTransactionId ?? "unknown",
+      errorCode: isSuccess ? "" : errorCode,
+      errorMessage: isSuccess
+        ? ""
+        : (rawParams.message ?? "Transaction failed without error details"),
+    };
+
+    if (isSuccess) {
+      result.transaction = this.mapCallbackToTransaction(rawParams);
+    }
+
+    const transactionId =
+      rawParams.transactionId ??
+      rawParams.orderCode ??
+      rawParams.clientTransactionId;
+    const errorReference =
+      rawParams.errorCode ??
+      this.extractErrorReferenceFromMessage(rawParams.message) ??
+      rawParams.referenceNumber ??
+      rawParams.tid ??
+      rawParams.rrn;
+
+    if (transactionId) {
+      result.transactionId = transactionId;
+    }
+
+    if (errorReference) {
+      result.errorReference = errorReference;
+    }
+
+    return {
+      rawParams,
+      result,
+    };
+  }
+
+  private matchesCallbackBase(url: string): boolean {
+    const actual = new URL(url);
+    const expected = new URL(this.appToAppConfig.callbackUrl);
+
+    return (
+      actual.protocol === expected.protocol &&
+      actual.hostname === expected.hostname &&
+      actual.pathname === expected.pathname
+    );
+  }
+
+  private matchesKnownTransactionId(rawParams: Record<string, string>): boolean {
+    const knownIds = [
+      this.currentClientTransactionId,
+      this.currentIsvClientTransactionId,
+    ].filter((value): value is string => Boolean(value));
+
+    if (knownIds.length === 0) {
+      return true;
+    }
+
+    const callbackIds = [
+      rawParams.clientTransactionId,
+      rawParams.ISV_clientTransactionId,
+    ].filter((value): value is string => Boolean(value));
+
+    if (callbackIds.length === 0) {
+      return true;
+    }
+
+    return callbackIds.some((callbackId) => knownIds.includes(callbackId));
+  }
+
+  private resolveFailureCode(
+    rawParams: Record<string, string>,
+    isCancelled: boolean,
+  ): string {
+    if (isCancelled) {
+      return PaymentFailureCode.PaymentCancelledByUser;
+    }
+
+    const rawErrorCode = rawParams.errorCode;
+    if (rawErrorCode?.includes(".")) {
+      return rawErrorCode;
+    }
+
+    if (this.isTransactionDetailsAction(rawParams)) {
+      const transactionType = (rawParams.transactionType ?? "").toLowerCase();
+      if (transactionType.includes("abort")) {
+        return PaymentFailureCode.SystemUnknown;
+      }
+    }
+
+    const rawMessage = (rawParams.message ?? "").toLowerCase();
+    const rawStatus = (rawParams.status ?? "").toLowerCase();
+
+    if (
+      rawMessage.includes("declined") ||
+      rawStatus === "declined" ||
+      rawStatus === "fail" ||
+      rawStatus === "failed"
+    ) {
+      return PaymentFailureCode.PaymentDeclined;
+    }
+
+    return PaymentFailureCode.SystemUnknown;
+  }
+
+  private isSuccessfulCallback(rawParams: Record<string, string>): boolean {
+    const rawStatus = (rawParams.status ?? "").toLowerCase();
+    if (!this.isTransactionDetailsAction(rawParams)) {
+      return rawStatus === "success";
+    }
+
+    if (rawStatus !== "success") {
+      return false;
+    }
+
+    const transactionType = (rawParams.transactionType ?? "").toLowerCase();
+    return !transactionType.includes("abort");
+  }
+
+  private isTransactionDetailsAction(rawParams: Record<string, string>): boolean {
+    return (rawParams.action ?? "").toLowerCase() ===
+      VIVA_ACTION_TRANSACTION_DETAILS.toLowerCase();
+  }
+
+  private isCancelledCallback(rawParams: Record<string, string>): boolean {
+    const rawStatus = (rawParams.status ?? "").toLowerCase();
+    const rawMessage = (rawParams.message ?? "").toLowerCase();
+    const rawErrorCode = (rawParams.errorCode ?? "").toLowerCase();
+
+    return (
+      rawStatus === "cancelled" ||
+      rawStatus === "canceled" ||
+      rawMessage.includes("user_cancel") ||
+      rawMessage.includes("user cancel") ||
+      rawErrorCode.includes("user_cancel") ||
+      rawErrorCode.includes("user cancel")
+    );
+  }
+
+  private extractErrorReferenceFromMessage(
+    message?: string,
+  ): string | undefined {
+    if (!message) {
+      return undefined;
+    }
+
+    const match = message.match(/\((-?\d+)\)/);
+    return match?.[1];
+  }
+
+  private mapCallbackToTransaction(rawParams: VivaCallbackParams): TransactionDto {
+    const transactionId =
+      rawParams.transactionId ??
+      rawParams.orderCode ??
+      rawParams.clientTransactionId ??
+      "unknown";
+    const timestamp = normalizeTimestamp(rawParams.transactionDate);
+    const amount = parseInteger(rawParams.amount);
+    const tipAmount = parseInteger(rawParams.tipAmount);
+
+    return {
+      amount,
+      cardDetail: {
+        aid: rawParams.aid ?? null,
+        applicationLabel: rawParams.applicationLabel ?? null,
+        cardNumber: rawParams.accountNumber ?? "N/A",
+        cardType: rawParams.cardType ?? "N/A",
+        issuer: rawParams.bankId ?? null,
+        orderCode: rawParams.orderCode ?? null,
+        timestamp,
+        transactionId,
+      },
+      createdAt: timestamp,
+      fees: this.buildFeesFromTip(tipAmount),
+      id: transactionId,
+      label: null,
+      provider: PaymentProvider.Viva,
+      rawData: rawParams,
+      referenceId: rawParams.clientTransactionId ?? null,
+      roundingDifference: 0,
+      type: this.getVivaPaymentMethodType(rawParams),
+    };
+  }
+
+  private getVivaPaymentMethodType(rawParams: VivaCallbackParams): PaymentMethod {
+    const applicationLabel = (rawParams.applicationLabel ?? "").toUpperCase().trim();
+    const maskedPan = rawParams.accountNumber ?? "";
+    const binPrefix = maskedPan.substring(0, 6);
+
+    if (binPrefix === EDENRED_BIN_PREFIX) {
+      return PaymentMethod.Edenred;
+    }
+
+    if (binPrefix === WOLT_BENEFIT_BIN_PREFIX) {
+      return PaymentMethod.WoltBenefit;
+    }
+
+    if (
+      CREDIT_KEYWORDS.some((keyword) => applicationLabel.includes(keyword))
+    ) {
+      return PaymentMethod.Credit;
+    }
+
+    return PaymentMethod.Debit;
+  }
+
+  private buildFeesFromTip(tipAmount: number): TransactionDtoFees | null {
+    if (!tipAmount || !this.currentCurrency) {
+      return null;
+    }
+
+    return {
+      parts: [
+        {
+          taxAmount: 0,
+          total: {
+            amount: tipAmount,
+            currency: this.currentCurrency,
+          },
+          type: FeeType.TipAmount,
+          vatPercentage: 0,
+        },
+      ],
+    };
+  }
+
+  private async lookupTransactionDetails(): Promise<PaymentResult | null> {
+    if (!this.currentClientTransactionId || !this.currentSourceTerminalId) {
+      return null;
+    }
+
+    const lookupParams = {
+      clientTransactionId: this.currentClientTransactionId,
+      sourceTerminalId: this.currentSourceTerminalId,
+    };
+
+    return new Promise<PaymentResult | null>((resolve) => {
+      let settled = false;
+
+      const timeoutId = setTimeout(() => {
+        if (settled) {
+          return;
+        }
+
+        settled = true;
+        unsubscribe();
+        resolve(null);
+      }, VIVA_TRANSACTION_DETAILS_TIMEOUT_MS);
+
+      const unsubscribe = this.appToAppConfig.adapter.subscribe((callbackUrl) => {
+        if (settled) {
+          return;
+        }
+
+        const parsed = this.parseCallbackUrl(callbackUrl);
+        if (!parsed) {
+          return;
+        }
+
+        if (!this.matchesKnownTransactionId(parsed.rawParams)) {
+          return;
+        }
+
+        settled = true;
+        clearTimeout(timeoutId);
+        unsubscribe();
+        resolve(parsed.result);
+      });
+
+      this.appToAppConfig.adapter
+        .openUrl(
+          this.buildActionUrl(VIVA_ACTION_TRANSACTION_DETAILS, lookupParams),
+        )
+        .catch(() => {
+          if (settled) {
+            return;
+          }
+
+          settled = true;
+          clearTimeout(timeoutId);
+          unsubscribe();
+          resolve(null);
+        });
+    });
+  }
+}