@fire-spark/payments-clisitef-pinpad-rn 0.11.1 → 0.12.0

package/dist/index.d.ts

@@ -7,6 +7,16 @@ declare const clisitefPinPadCapabilities: PaymentAdapterCapabilities;
 type ClisitefPinPadOptions = {
   /** Defaults to the shared client bound to the native module. */
   client?: ClisitefClient;
+  /**
+   * Prints `[CLISITEF_DEBUG]` traces in the console and Android logcat.
+   * Off unless set. These lines are not sent to the backend.
+   */
+  debug?: boolean;
+  /**
+   * Sends the `info` logs of a pinpad decline or cancel. Errors are always
+   * sent. On unless set to `false`.
+   */
+  traces?: boolean;
   /**
    * Device-wide storage for the pending-transaction record. Defaults to
    * `ctx.storage`, which is scoped per payment: a transaction left open by
@@ -245,6 +255,8 @@ type ClisitefVoidDeps = {
   now: () => Date;
   timeZone?: string;
   confirmationTimeoutMs: number;
+  /** Gates the `info` decline. Errors are always sent. */
+  traces: boolean;
 };
 type ClisitefVoidContext = {
   ui: PaymentUI;
@@ -308,6 +320,14 @@ declare const readTransaction: (storage: PaymentStorage, key?: string) => Promis
 declare const writeTransaction: (storage: PaymentStorage, record: ClisitefTransactionRecord, key?: string) => Promise<void>;
 declare const isOpen: (record: ClisitefTransactionRecord) => boolean;
 //#endregion
+//#region src/trace.d.ts
+type PinpadTrace = {
+  call: (body: string) => void;
+  result: (body: string) => void;
+  note: (body: string) => void;
+  detail: () => string;
+};
+//#endregion
 //#region src/transaction.d.ts
 /**
  * `confirmed`: `stage 2` closed with 0. `declined`: failed before the card
@@ -327,6 +347,8 @@ type ClisitefOutcome = {
   evidence: boolean;
   /** Error thrown by `ctx.ui` (e.g. the customer did not answer). */
   error?: unknown;
+  /** Native failure attached to the backend log. The charge does not rethrow it. */
+  cause?: unknown;
 };
 type ClisitefTransactionInput = {
   client: ClisitefClient;
@@ -342,6 +364,8 @@ type ClisitefTransactionInput = {
   onApproved: (fields: ClisitefFields) => Promise<void>;
   /** Answer for a `READ_*` field without the UI; `null` asks `ui.input`. */
   answerField?: (fieldId: number) => string | null;
+  /** Steps of this call. The adapter sends them once, when the call ends. */
+  trace?: PinpadTrace;
 };
 /**
  * One CliSiTef transaction: `startTransaction`, the `onData` loop answered

package/dist/index.js

@@ -1,5 +1,6 @@
 import { PaymentError, createPaymentError, definePaymentErrors, toPaymentError } from "@fire-spark/payments";
-import { CLISITEF_ABORT_FLAG, CLISITEF_CONFIRM, CLISITEF_MODALITY, CLISITEF_RESULT, CLISITEF_TIMEOUT_CODE, CLISITEF_VOID_FUNCTION, clisitef, clisitefAdditionalParams, clisitefDebug, clisitefDebugCall, clisitefFiscalDateTime, formatClisitefAmount, parseClisitefMenu } from "@fire-spark/payments-clisitef-client";
+import { CLISITEF_ABORT_FLAG, CLISITEF_CONFIRM, CLISITEF_MODALITY, CLISITEF_RESULT, CLISITEF_TIMEOUT_CODE, CLISITEF_VOID_FUNCTION, clisitef, clisitefAdditionalParams, clisitefDebug, clisitefDebugCall, clisitefFiscalDateTime, formatClisitefAmount, parseClisitefMenu, setClisitefLogs } from "@fire-spark/payments-clisitef-client";
+import { log, logError } from "@fire-spark/core";
 //#region src/constants.ts
 /**
 * `onData` commands handled by the adapter (Fiserv "Tabela de códigos de
@@ -289,6 +290,103 @@ const clisitefDetails = (metadata) => {
 	};
 };
 //#endregion
+//#region src/report.ts
+/** Same `log` / `logError` the templates import from `@fire-spark/storefront`. */
+const CHARGE_DID_NOT_START = "CliSiTef charge did not start";
+const CHARGE_DECLINED = "CliSiTef charge declined";
+const CHARGE_DID_NOT_FINISH = "CliSiTef charge did not finish";
+const VOID_DECLINED = "CliSiTef void declined";
+const VOID_DID_NOT_FINISH = "CliSiTef void did not finish";
+const PENDING_RECOVERED = "CliSiTef pending transaction recovered";
+const ROUTINE_RELEASED = "CliSiTef open routine released";
+/** Fixed phrase as the log message; the thrown value keeps its name and stack. */
+const reportedError = (message, error) => {
+	const wrapped = new Error(message);
+	if (error instanceof Error) {
+		wrapped.name = error.name;
+		if (error.stack) wrapped.stack = error.stack;
+		wrapped.cause = error;
+		return wrapped;
+	}
+	wrapped.cause = error;
+	return wrapped;
+};
+/** One backend log. `info` is skipped when `traces` is off. Never throws. */
+const reportPinpad = (input) => {
+	if (input.level === "info" && !input.traces) return;
+	const options = {
+		alias: input.alias,
+		status: input.status,
+		detail: input.detail
+	};
+	if (!(input.level === "error" && input.error != null)) {
+		log(input.level, input.message, options);
+		return;
+	}
+	logError(reportedError(input.message, input.error), options);
+};
+const isTimeout = (outcome) => {
+	if (outcome.code === CLISITEF_TIMEOUT_CODE) return true;
+	const { error } = outcome;
+	if (!(error instanceof Error)) return false;
+	return error.name === "ClisitefTimeoutError";
+};
+/** SiTef or the customer answered with a numeric code. */
+const pinpadDecline = (outcome) => {
+	return outcome.status === "declined" && typeof outcome.code === "number";
+};
+const finishStatus = (outcome) => {
+	const { status } = outcome;
+	if (status === "open" || status === "unresolved") return status;
+	if (status === "undone") return status;
+	return "open";
+};
+/**
+* Case 2 (`info`) when the pinpad or the customer closed the charge.
+* Case 3 (`error`) when it stayed open, the undo failed, or a timeout cut it.
+* A confirmed charge sends nothing.
+*/
+const reportChargeOutcome = (traces, trace, outcome) => {
+	if (outcome.status === "confirmed") return;
+	const answered = pinpadDecline(outcome) && !isTimeout(outcome);
+	const quiet = outcome.status === "declined" && !outcome.aborted;
+	if (answered || quiet && !isTimeout(outcome)) {
+		const body = {
+			level: "info",
+			alias: "clisitef.charge"
+		};
+		const text = {
+			status: "declined",
+			message: CHARGE_DECLINED
+		};
+		reportPinpad({
+			...body,
+			...text,
+			detail: trace.detail(),
+			traces
+		});
+		return;
+	}
+	if (outcome.status === "undone" && !outcome.evidence && !outcome.aborted && !isTimeout(outcome)) return;
+	const body = {
+		level: "error",
+		alias: "clisitef.charge"
+	};
+	const status = finishStatus(outcome);
+	const message = CHARGE_DID_NOT_FINISH;
+	const detail = trace.detail();
+	const failure = outcome.cause ?? outcome.error;
+	const sent = {
+		...body,
+		status,
+		message,
+		detail,
+		traces,
+		error: failure
+	};
+	reportPinpad(sent);
+};
+//#endregion
 //#region src/reversals.ts
 const readJson = async (storage, key) => {
 	const raw = await storage.get(key);
@@ -338,6 +436,47 @@ const writeRefund = async (storage, attemptReference, result) => {
 	await storage.set(CLISITEF_REFUNDS_KEY, JSON.stringify(next));
 };
 //#endregion
+//#region src/trace.ts
+/** One in-call trace. Discarded on success; it is not stored on the device. */
+const DETAIL_MAX = 2e3;
+const MARK = "\n…\n";
+/** 14–19 digits. A 13-digit fiscal coupon (`Date.now()`) stays as-is. */
+const PAN = /\d{14,19}/g;
+/** Track 1/2 sentinels. The payload is not a field we record on purpose. */
+const TRACK = /[%;][\dA-Za-z=^]{12,}/g;
+const pad = (value, width) => {
+	return String(value).padStart(width, "0");
+};
+/** Local kiosk time of the step, not the time the log is posted. */
+const pinpadStamp = (date) => {
+	return `${pad(date.getHours(), 2)}:${pad(date.getMinutes(), 2)}:${pad(date.getSeconds(), 2)}.${pad(date.getMilliseconds(), 3)}`;
+};
+/** PAN and track data only. Amounts, dates and the fiscal coupon stay. */
+const maskCardData = (value) => {
+	return value.replace(TRACK, "<track>").replace(PAN, (digits) => {
+		return `************${digits.slice(-4)}`;
+	});
+};
+/** Keeps the start and the end when `detail` would pass 2000 characters. */
+const fitDetail = (text) => {
+	if (text.length <= DETAIL_MAX) return text;
+	const head = Math.ceil((DETAIL_MAX - 3) / 2);
+	return `${text.slice(0, head)}${MARK}${text.slice(-998)}`;
+};
+const createPinpadTrace = (now = () => /* @__PURE__ */ new Date()) => {
+	const lines = [];
+	const push = (body) => {
+		const stamp = pinpadStamp(now());
+		lines.push(`${stamp} ${maskCardData(body)}`);
+	};
+	return {
+		call: (body) => push(`→ ${body}`),
+		result: (body) => push(`← ${body}`),
+		note: (body) => push(body),
+		detail: () => fitDetail(lines.join("\n"))
+	};
+};
+//#endregion
 //#region src/menu.ts
 const normalize = (label) => {
 	return label.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toUpperCase();
@@ -455,7 +594,27 @@ const redact = (event) => {
 * success only when `stage 2` closes with 0. Never rejects.
 */
 const runClisitefTransaction = (input) => {
-	const { client, ui, signal } = input;
+	const { client, ui, signal, trace } = input;
+	const yesNo = (value) => {
+		if (value) return "yes";
+		return "no";
+	};
+	const startLine = () => {
+		const { start } = input;
+		const modality = `modality=${input.modality}`;
+		const fn = `function=${start.modality}`;
+		const value = `value=${start.value}`;
+		const coupon = `coupon=${start.fiscalCoupon}`;
+		const date = `date=${start.fiscalDate}`;
+		const time = `time=${start.time}`;
+		const head = `start ${modality} ${fn} ${value}`;
+		const when = `${coupon} ${date} ${time}`;
+		if (!start.restrictions) return `${head} ${when}`;
+		return `${head} ${when} restrictions=${start.restrictions}`;
+	};
+	const finishLine = (confirm) => {
+		return `finish confirm=${confirm} coupon=${input.finish.fiscalCoupon}`;
+	};
 	const fields = /* @__PURE__ */ new Map();
 	const subscriptions = [];
 	let title = "";
@@ -487,6 +646,8 @@ const runClisitefTransaction = (input) => {
 			...reason,
 			fieldIds: [...fields.keys()]
 		});
+		const evidence = `evidence=${yesNo(captured)}`;
+		trace?.note(`${evidence} aborted=${yesNo(aborted)}`);
 		clearTimeout(watchdog);
 		for (const subscription of subscriptions) subscription.remove();
 		signal.removeEventListener("abort", onAbort);
@@ -500,17 +661,22 @@ const runClisitefTransaction = (input) => {
 	};
 	const undo = async (reason) => {
 		log("undo (finishTransaction 0)", reason);
+		trace?.call(finishLine(CLISITEF_CONFIRM.UNDO));
 		try {
 			const p1 = {
 				confirm: CLISITEF_CONFIRM.UNDO,
 				...input.finish
 			};
-			await client.finishTransaction(p1);
+			const code = await client.finishTransaction(p1);
+			trace?.result(`finish ${code}`);
 			settle("undone", reason);
 		} catch (error) {
+			trace?.result("finish error");
+			const message = errorMessage(error);
 			settle("unresolved", {
 				...reason,
-				message: errorMessage(error)
+				message,
+				cause: error
 			});
 		}
 	};
@@ -723,13 +889,19 @@ const runClisitefTransaction = (input) => {
 			...p1,
 			watchdogMs: input.confirmationTimeoutMs
 		});
-		client.finishTransaction(p1).catch((error) => {
+		trace?.call(finishLine(CLISITEF_CONFIRM.CONFIRM));
+		client.finishTransaction(p1).then((code) => trace?.result(`finish ${code}`)).catch((error) => {
+			trace?.result("finish error");
 			if (closing) return;
 			closing = true;
 			clearTimeout(watchdog);
-			undo({
+			const reason = {
 				code: errorCode(error),
 				message: errorMessage(error)
+			};
+			return undo({
+				...reason,
+				cause: error
 			});
 		});
 	};
@@ -755,6 +927,7 @@ const runClisitefTransaction = (input) => {
 			code,
 			skipped: closing
 		});
+		if (!closing) trace?.result(`stage ${stage} ${code}`);
 		if (closing) return;
 		if (givingUp && stage === 1) return windDown(givingUp, code);
 		if (stage === 1 && code === CLISITEF_RESULT.OK) {
@@ -827,10 +1000,12 @@ const runClisitefTransaction = (input) => {
 		};
 		subscriptions.push(client.onData(handleData));
 		subscriptions.push(client.onTransactionResult(handleResult));
+		trace?.call(startLine());
 		try {
 			const code = await client.startTransaction(input.start);
 			if (code === CLISITEF_RESULT.CONTINUE || closing) return;
 			closing = true;
+			trace?.result(`start ${code}`);
 			settle("declined", {
 				code,
 				message: null
@@ -838,11 +1013,15 @@ const runClisitefTransaction = (input) => {
 		} catch (error) {
 			if (closing) return;
 			closing = true;
+			trace?.result("start error");
 			const reason = {
 				code: errorCode(error),
 				message: errorMessage(error)
 			};
-			settle("declined", reason);
+			settle("declined", {
+				...reason,
+				cause: error
+			});
 		}
 	};
 	begin();
@@ -944,8 +1123,26 @@ const runClisitefVoid = async (deps, ctx, result) => {
 	const reference = result.metadata.attempt_reference;
 	const done = await readRefund(ctx.storage, reference);
 	if (done) return done;
+	const trace = createPinpadTrace(deps.now);
+	const voidLog = (level, status, error) => {
+		const body = {
+			level,
+			alias: "clisitef.void",
+			status,
+			message: level === "info" ? VOID_DECLINED : VOID_DID_NOT_FINISH
+		};
+		const detail = trace.detail();
+		reportPinpad({
+			...body,
+			detail,
+			traces: deps.traces,
+			error
+		});
+	};
 	const target = targetOf(result);
 	if (!target) {
+		trace.note(`missing reference=${reference}`);
+		voidLog("error", "unavailable");
 		const error = createPaymentError("MANUAL_REVERSAL_REQUIRED", {
 			message: "Missing CliSiTef void context (host NSU, date, modality)",
 			retryable: false,
@@ -976,6 +1173,8 @@ const runClisitefVoid = async (deps, ctx, result) => {
 		return paid;
 	};
 	if (ctx.unavailable) {
+		trace.note(`unavailable reference=${reference}`);
+		voidLog("error", "unavailable");
 		const error = {
 			...ctx.unavailable,
 			retryable: true
@@ -1002,6 +1201,9 @@ const runClisitefVoid = async (deps, ctx, result) => {
 		[CLISITEF_VOID_FIELD.ORIGINAL_HOST_NSU]: target.hostNsu
 	};
 	if (settings.supervisorPassword) answers[CLISITEF_VOID_FIELD.SUPERVISOR_PASSWORD] = settings.supervisorPassword;
+	const nsu = `nsu=${target.hostNsu}`;
+	const original = `original=${target.transactionDate}`;
+	trace.call(`void ${nsu} ${original}`);
 	const outcome = await runClisitefTransaction({
 		client: deps.client,
 		ui: ctx.ui,
@@ -1015,7 +1217,8 @@ const runClisitefVoid = async (deps, ctx, result) => {
 		modality: target.modality,
 		purpose: "void",
 		onApproved: async () => void 0,
-		answerField: (fieldId) => answers[fieldId] ?? null
+		answerField: (fieldId) => answers[fieldId] ?? null,
+		trace
 	});
 	if (outcome.code === -1) deps.client.invalidate();
 	const voided = clisitefVoidMetadata({
@@ -1045,6 +1248,8 @@ const runClisitefVoid = async (deps, ctx, result) => {
 		await dropReversal(ctx.storage, reference);
 		return refunded;
 	}
+	if (isDefinitive(outcome)) voidLog("info", "declined");
+	else voidLog("error", "queued", outcome.cause ?? outcome.error);
 	const error = voidError(outcome, ctx.attempt);
 	const withVoid = {
 		...result,
@@ -1374,6 +1579,8 @@ const terminalError = (error) => {
 * default.
 */
 const clisitefPinPadPayments = (options = {}) => {
+	setClisitefLogs(options.debug === true);
+	const traces = options.traces !== false;
 	const client = options.client ?? clisitef;
 	const now = options.now ?? (() => /* @__PURE__ */ new Date());
 	const confirmationMs = options.confirmationTimeoutMs ?? 6e4;
@@ -1385,11 +1592,41 @@ const clisitefPinPadPayments = (options = {}) => {
 	const storageOf = (ctx) => {
 		return options.storage ?? ctx.storage;
 	};
-	const configure = async (settings) => {
-		const code = await client.configure(settings.configure);
+	const chargeStart = (trace, status) => {
+		const body = {
+			level: "error",
+			alias: "clisitef.charge"
+		};
+		const text = {
+			status,
+			message: CHARGE_DID_NOT_START,
+			traces
+		};
+		reportPinpad({
+			...body,
+			...text,
+			detail: trace.detail()
+		});
+	};
+	const configure = async (settings, trace) => {
+		const { terminalNumber } = settings;
+		const { storeCode, serverIp } = settings.configure;
+		const terminal = `terminal=${terminalNumber}`;
+		const store = `store=${storeCode}`;
+		const ip = `ip=${serverIp}`;
+		trace?.call(`configure ${terminal} ${store} ${ip}`);
+		let code;
+		try {
+			code = await client.configure(settings.configure);
+		} catch (error) {
+			trace?.result("configure error");
+			throw error;
+		}
+		trace?.result(`configure ${code}`);
+		const shown = redactSecrets(settings);
 		clisitefDebug("pinpad.adapter.configure", "result", {
 			code,
-			settings: redactSecrets(settings)
+			settings: shown
 		});
 		if (code === 0) return null;
 		client.invalidate();
@@ -1405,12 +1642,16 @@ const clisitefPinPadPayments = (options = {}) => {
 	const recover = async (storage, record, key = CLISITEF_STORAGE_KEY) => {
 		const { fiscalCoupon, fiscalDate, time } = record;
 		const count = client.getQttPendingTransactions;
+		const trace = createPinpadTrace(now);
+		const coupon = `coupon=${fiscalCoupon}`;
+		trace.call(`pending ${coupon} date=${fiscalDate}`);
 		const pending = await count(fiscalDate, fiscalCoupon).catch(() => null);
 		clisitefDebug("pinpad.adapter.recover", "pending", {
 			pending,
 			record
 		});
 		if (pending === null) return record;
+		trace.result(`pending ${pending}`);
 		if (pending === 0 && record.state === "review") return record;
 		let next;
 		if (pending > 0) {
@@ -1419,10 +1660,13 @@ const clisitefPinPadPayments = (options = {}) => {
 				fiscalCoupon,
 				fiscalDate
 			};
-			if (await client.finishTransaction({
+			trace.call(`finish confirm=0 ${coupon}`);
+			const code = await client.finishTransaction({
 				...p1,
 				time
-			}).catch(() => -1) !== 0) return record;
+			}).catch(() => -1);
+			trace.result(`finish ${code}`);
+			if (code !== 0) return record;
 			const error = createPaymentError("PROVIDER_UNAVAILABLE", {
 				retryable: false,
 				message: "Pending CliSiTef transaction undone"
@@ -1451,6 +1695,25 @@ const clisitefPinPadPayments = (options = {}) => {
 			};
 		}
 		clisitefDebug("pinpad.adapter.recover", `→ ${next.state}`, next);
+		if (next.state === "undone") {
+			const previous = `previous=${record.state}`;
+			const reference = `reference=${record.attemptReference}`;
+			trace.note(`${previous} ${reference} ${coupon} state=undone`);
+			const body = {
+				level: "error",
+				alias: "clisitef.pending"
+			};
+			const text = {
+				status: "undone",
+				message: PENDING_RECOVERED,
+				traces
+			};
+			reportPinpad({
+				...body,
+				...text,
+				detail: trace.detail()
+			});
+		}
 		await writeTransaction(storage, next, key);
 		return next;
 	};
@@ -1467,23 +1730,42 @@ const clisitefPinPadPayments = (options = {}) => {
 	const releaseRoutine = () => {
 		clisitefDebug("pinpad.adapter.release", "routine", { releaseMs });
 		leftOpen = false;
+		const trace = createPinpadTrace(now);
 		const subscriptions = [];
 		let timer;
+		let closed = false;
+		let stage1 = false;
 		const abort = () => {
 			client.abortTransaction(CLISITEF_ABORT_FLAG).catch(() => 0);
 		};
 		return new Promise((resolve) => {
 			const done = () => {
+				if (closed) return;
+				closed = true;
 				clearTimeout(timer);
 				for (const subscription of subscriptions) subscription.remove();
 				client.invalidate();
+				const status = stage1 ? "released" : "release_timeout";
+				if (stage1) trace.result("stage 1");
+				else trace.result("timeout");
+				reportPinpad({
+					level: "error",
+					alias: "clisitef.pending",
+					status,
+					message: ROUTINE_RELEASED,
+					traces,
+					detail: trace.detail()
+				});
 				resolve();
 			};
 			subscriptions.push(client.onData(abort));
 			subscriptions.push(client.onTransactionResult((event) => {
-				if (event.stage === 1) done();
+				if (event.stage !== 1) return;
+				stage1 = true;
+				done();
 			}));
 			timer = setTimeout(done, releaseMs);
+			trace.call("abortTransaction -1");
 			abort();
 		});
 	};
@@ -1496,14 +1778,14 @@ const clisitefPinPadPayments = (options = {}) => {
 		return isOpen(record) || record.state === "review";
 	};
 	/** Configures and resolves the open records of the device, if any. */
-	const prepare = async (ctx) => {
+	const prepare = async (ctx, trace) => {
 		const settings = readClisitefPinPadSettings(ctx.config, ctx.deviceSettings);
 		if (leftOpen) await releaseRoutine();
-		let error = await configure(settings);
+		let error = await configure(settings, trace);
 		if (isConfigureBusy(error)) {
 			clisitefDebug("pinpad.adapter.release", "busy", {});
 			await releaseRoutine();
-			error = await configure(settings);
+			error = await configure(settings, trace);
 		}
 		const storage = storageOf(ctx);
 		const resolve = async (key) => {
@@ -1547,15 +1829,43 @@ const clisitefPinPadPayments = (options = {}) => {
 		const amount = ctx.amount.value;
 		const reference = ctx.attemptReference;
 		const empty = { amount };
+		const trace = createPinpadTrace(now);
 		if (!client.available) {
+			trace.note(`unavailable reference=${reference}`);
+			chargeStart(trace, "unavailable");
 			const error = createPaymentError("TERMINAL_UNAVAILABLE");
 			return failed(empty, reference, error);
 		}
-		const prepared = await prepare(ctx);
+		let prepared;
+		try {
+			prepared = await prepare(ctx, trace);
+		} catch (error) {
+			const body = {
+				level: "error",
+				alias: "clisitef.charge"
+			};
+			const text = {
+				status: "configure_failed",
+				message: CHARGE_DID_NOT_START
+			};
+			reportPinpad({
+				...body,
+				...text,
+				detail: trace.detail(),
+				traces,
+				error
+			});
+			throw error;
+		}
 		const { settings, storage, record: previous } = prepared;
-		if (prepared.error) return failed(empty, reference, prepared.error);
+		if (prepared.error) {
+			chargeStart(trace, "configure_failed");
+			return failed(empty, reference, prepared.error);
+		}
 		if (previous?.attemptReference === reference && previous?.state === "confirmed") return paid(previous);
 		if (busy([previous, prepared.refund])) {
+			trace.note(`busy reference=${reference}`);
+			chargeStart(trace, "busy");
 			const error = createPaymentError("TERMINAL_BUSY", { attempt: ctx.attempt });
 			return failed(empty, reference, error);
 		}
@@ -1622,7 +1932,8 @@ const clisitefPinPadPayments = (options = {}) => {
 		};
 		const t2 = {
 			confirmationTimeoutMs: confirmationMs,
-			onApproved
+			onApproved,
+			trace
 		};
 		const t3 = {
 			modality: chosen,
@@ -1636,9 +1947,10 @@ const clisitefPinPadPayments = (options = {}) => {
 		let outcome = await run();
 		if (isStartBusy(outcome)) {
 			await releaseRoutine();
-			if (!await configure(settings)) outcome = await run();
+			if (!await configure(settings, trace)) outcome = await run();
 		}
 		if (outcome.status === "open") leftOpen = true;
+		reportChargeOutcome(traces, trace, outcome);
 		const fields = Object.fromEntries(outcome.fields);
 		clisitefDebug("pinpad.adapter.charge", "outcome", {
 			...outcome,
@@ -1673,7 +1985,8 @@ const clisitefPinPadPayments = (options = {}) => {
 		client,
 		now,
 		timeZone: options.timeZone,
-		confirmationTimeoutMs: confirmationMs
+		confirmationTimeoutMs: confirmationMs,
+		traces
 	};
 	/** Prepares the pinpad (recovering an open charge) and voids `result`. */
 	const refund = async (ctx, result) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fire-spark/payments-clisitef-pinpad-rn",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "description": "Fire Spark CliSiTef (Software Express) pinpad adapter for Brazil: debit, credit, voucher and Pix with automatic voids on Android kiosks",
   "type": "module",
   "sideEffects": false,
@@ -17,9 +17,10 @@
     }
   },
   "dependencies": {
-    "@fire-spark/payments": "^0.11.1",
-    "@fire-spark/payments-clisitef-client": "^0.11.1",
-    "@fire-spark/types": "^0.11.1"
+    "@fire-spark/core": "^0.12.0",
+    "@fire-spark/payments": "^0.12.0",
+    "@fire-spark/payments-clisitef-client": "^0.12.0",
+    "@fire-spark/types": "^0.12.0"
   },
   "devDependencies": {
     "tsdown": "^0.22.14",
@@ -43,6 +44,7 @@
     "clean": true,
     "deps": {
       "neverBundle": [
+        "@fire-spark/core",
         "@fire-spark/payments",
         "@fire-spark/payments-clisitef-client",
         "@fire-spark/types"