@visa/cli 4.1.0-rc.148 → 4.1.0-rc.149

package/dist/checkout-engine/cli-engine.d.ts

@@ -65,11 +65,11 @@ export type CliReceiptFacts = {
     vicConfirmation: VicConfirmationReport | null;
     /**
      * Which credential path actually ran: `mandate` = tap-free draw against an
-     * existing card mandate; `fresh-tap` = today's 1:1 hosted-passkey mint; `null`
-     * = neither ran (a pre-flight refusal, e.g. no prepared review). Transparency,
-     * never magic — the caller can always see whether a passkey was skipped.
+     * existing card mandate; `null` = none ran (a pre-flight refusal, e.g. no
+     * prepared review or no covering mandate). Transparency, never magic — the
+     * caller can always see whether a passkey was skipped.
      */
-    source: 'mandate' | 'fresh-tap' | null;
+    source: 'mandate' | null;
     /** Remaining mandate budget (minor units) after a mandate draw; else null. */
     remainingMinor: number | null;
     /**

package/dist/checkout-engine/cli-engine.js

@@ -318,8 +318,7 @@ export function createCliCheckoutEngine(deps = {}) {
             };
             // BUDGET mode: the ceiling target's amount IS the approved ceiling, so the
             // server mints a budget mint token bound to that ceiling — later draws pull
-            // sub-ceiling amounts against it tap-free (the single-purchase fresh-tap
-            // path below stays non-budget).
+            // sub-ceiling amounts against it tap-free.
             const assurance = await runHostedApproval({
                 baseUrl: input.approvalBaseUrl,
                 tokenId: credential.tokenId,
@@ -623,14 +622,15 @@ export function createCliCheckoutEngine(deps = {}) {
             try {
                 // NO instrument read here. A tap-free mandate draw spends `covering
                 // .tokenId` (frozen into the mandate at start) and needs neither the
-                // legacy credential file nor a grant token; only the fresh-tap branch
-                // below needs one, and it resolves lazily so a grant-only device with an
-                // as-yet-unrefreshed token can still draw on a mandate it already holds.
+                // legacy credential file nor a grant token, so a grant-only device with
+                // an as-yet-unrefreshed token can still draw on a mandate it already
+                // holds.
                 const host = new URL(session.target.merchantUrl).hostname;
                 // Does an ACTIVE card mandate already cover this exact purchase? If so,
-                // draw against it TAP-FREE (no hosted passkey). Else fall back to today's
-                // 1:1 fresh-tap flow. Mandates no longer persist the bootstrap token:
-                // it is consumed by intent creation + register and has no draw power.
+                // draw against it TAP-FREE (no hosted passkey). Else refuse with the
+                // mandate remedy (#7348). Mandates no longer persist the bootstrap
+                // token: it is consumed by intent creation + register and has no draw
+                // power.
                 const covering = await ledger.findCovering({
                     merchantHost: host,
                     currencyCode: session.currency,
@@ -640,9 +640,8 @@ export function createCliCheckoutEngine(deps = {}) {
                 });
                 let source;
                 let confirmBase;
-                // Fresh purchases confirm with their one-purchase mint token. Mandate
-                // draws set this only after the local reserve succeeds and auth returns
-                // the exact per-draw verdict used to mint the credential.
+                // Mandate draws set this only after the local reserve succeeds and auth
+                // returns the exact per-draw verdict used to mint the credential.
                 let confirmationAuthority = null;
                 let drawnRemaining = null;
                 let instrument;
@@ -667,7 +666,7 @@ export function createCliCheckoutEngine(deps = {}) {
                             confirmationRef: null,
                             receiptPath: null,
                             detail: 'this mandate cannot draw because its delegated card authority is unavailable; ' +
-                                'restore the runtime binding or use a fresh per-purchase approval',
+                                're-pair this runtime to restore the binding, or start a new mandate for this agent',
                             vicConfirmation: null,
                             source,
                             remainingMinor: null,
@@ -679,7 +678,7 @@ export function createCliCheckoutEngine(deps = {}) {
                             confirmationRef: null,
                             receiptPath: null,
                             detail: 'this budget belongs to a different request key than the selected card capability; ' +
-                                'restore that exact runtime key or use a fresh per-purchase approval',
+                                'restore that exact runtime key, or start a new mandate from the current runtime',
                             vicConfirmation: null,
                             source,
                             remainingMinor: null,
@@ -739,7 +738,8 @@ export function createCliCheckoutEngine(deps = {}) {
                             // (MandateDrawDeclinedError). That case leaves the mandate
                             // active+covering, so a naive retry would re-select it and fail
                             // identically — trapping the caller; marking it unhonored makes the
-                            // next pay_merchant skip it and take a fresh per-purchase tap. We do
+                            // next pay_merchant skip it and surface the no-covering-mandate refusal
+                            // (#7348) instead of re-failing identically. We do
                             // NOT attempt an unsafe same-call browser fallback mid-submit.
                             //
                             // A PRE-network failure — reserve() failing closed on a concurrent
@@ -765,9 +765,7 @@ export function createCliCheckoutEngine(deps = {}) {
                                     }
                                     throw new Error(verdictFailure.transient
                                         ? `the card-mandate draw could not be authorized right now (${verdictFailure.reasons.join(', ') || 'temporary error'}) — retry shortly`
-                                        : `this card mandate can no longer be drawn (${verdictFailure.reasons.join(', ') || 'refused'}); it has been disabled — ${isV4CardGrant
-                                            ? 'create and claim a new mandate before retrying this v4 checkout'
-                                            : 'retry the checkout to use a legacy fresh per-purchase approval'}`, { cause: err });
+                                        : `this card mandate can no longer be drawn (${verdictFailure.reasons.join(', ') || 'refused'}); it has been disabled — create and claim a new mandate before retrying this checkout`, { cause: err });
                                 }
                                 if (!isTransientDrawFailure(err.cause ?? err)) {
                                     await ledger.markUnhonored(mandateId, now());
@@ -785,8 +783,8 @@ export function createCliCheckoutEngine(deps = {}) {
                     instrument = new VgsLiveInstrument(reference, session.contact.fullName ?? '', fetchCredential);
                 }
                 else {
-                    // #7348 fresh-tap retirement: card spend is mandate-only for EVERY
-                    // runtime. The legacy 1:1 fresh-tap flow that lived here minted a
+                    // #7348 single-purchase retirement: card spend is mandate-only for
+                    // EVERY runtime. The legacy 1:1 single-purchase flow here minted a
                     // payable credential outside the grant/mandate ledger — invisible to
                     // spending controls. The server now refuses non-budget approvals at
                     // registration and non-budget mint tokens at verification; this

package/dist/checkout-engine/hosted-approval.d.ts

@@ -34,23 +34,24 @@ export type HostedApprovalOptions = {
     /** Prefills the approval page's enrollment-email field (optional). */
     consumerEmail?: string;
     /**
-     * BUDGET/mandate approval: `target.transactionAmount` is the approved spend
-     * CEILING (not one charge), so the server mints a BUDGET mint token that later
-     * accepts many sub-ceiling draws tap-free. Omit for a single-purchase approval.
+     * BUDGET/mandate approval — the only kind since #7348 retired the
+     * single-purchase plane: `target.transactionAmount` is the approved spend
+     * CEILING (not one charge), so the server mints a BUDGET mint token that
+     * later accepts many sub-ceiling draws tap-free.
      */
-    budget?: boolean;
+    budget: true;
     /**
-     * Exact current request-key thumbprint receiving a budget. Required for a
-     * budget and forbidden for a one-purchase approval; the authenticated page
-     * resolves it to the owner's stable agent before displaying or signing.
+     * Exact current request-key thumbprint receiving the budget; the
+     * authenticated page resolves it to the owner's stable agent before
+     * displaying or signing.
      */
-    agentJkt?: string;
-    /** Advisory max draws the ceiling intent may fulfil — carried onto the token. */
-    maxDraws?: number;
+    agentJkt: string;
+    /** Max draws the ceiling intent may fulfil — carried onto the token. */
+    maxDraws: number;
     /**
-     * Per-purchase cap (decimal string, <= the ceiling) on a BUDGET approval —
-     * shown on the approval page as a worst-case term and carried onto the mint
-     * token so the displayed cap is the enforced cap. Budget mode only.
+     * Per-purchase cap (decimal string, <= the ceiling) — shown on the approval
+     * page as a worst-case term and carried onto the mint token so the displayed
+     * cap is the enforced cap.
      */
     perTransaction?: string;
     /**

package/dist/checkout-engine/hosted-approval.js

@@ -128,7 +128,7 @@ function stripTrailingSlashes(value) {
  * rather than falling back to a client-held secret.
  */
 export async function runHostedApproval(opts) {
-    const { baseUrl, tokenId, target, consumerEmail, budget, agentJkt, maxDraws, perTransaction, intent, 
+    const { baseUrl, tokenId, target, consumerEmail, agentJkt, maxDraws, perTransaction, intent, 
     // Default to stderr, NOT a no-op: the approval URL is the one thing a remote /
     // SSH / headless-terminal human needs to proceed, and swallowing it (the old
     // `() => {}` default) left it emitted nowhere readable. Tests inject their own.
@@ -138,12 +138,9 @@ export async function runHostedApproval(opts) {
     // override without threading a flag through every caller.
     timeoutMs = resolveApprovalTimeoutMs(), } = opts;
     const canonicalJkt = typeof agentJkt === 'string' && /^[A-Za-z0-9_-]{43}$/.test(agentJkt);
-    if (budget && !canonicalJkt) {
+    if (!canonicalJkt) {
         throw new Error('a budget approval requires the exact current agent request-key JKT');
     }
-    if (!budget && agentJkt !== undefined) {
-        throw new Error('agentJkt is accepted only for a budget approval');
-    }
     const base = stripTrailingSlashes(assertApprovalBaseUrl(baseUrl));
     // The server's currency map is uppercase ISO 4217; the loader normalizes the
     // target once, but normalize here too so a direct caller with a lowercase
@@ -194,10 +191,10 @@ export async function runHostedApproval(opts) {
                 amount: target.transactionAmount,
                 currency,
                 ...(consumerEmail ? { consumerEmail } : {}),
-                ...(budget ? { budget: true } : {}),
-                ...(budget ? { agentJkt } : {}),
-                ...(budget && maxDraws !== undefined ? { maxDraws } : {}),
-                ...(budget && perTransaction !== undefined ? { perTransaction } : {}),
+                budget: true,
+                agentJkt,
+                maxDraws,
+                ...(perTransaction !== undefined ? { perTransaction } : {}),
                 ...(intentSanitized !== undefined ? { intent: intentSanitized } : {}),
             },
         }),
@@ -214,9 +211,7 @@ export async function runHostedApproval(opts) {
     // effort browser open for the interactive case.
     onApprovalUrl?.(approveUrl);
     log(`approve the purchase in your browser: ${approveUrl}`);
-    if (budget && agentJkt) {
-        log(`budget recipient request key: ${agentJkt.slice(0, 8)}…${agentJkt.slice(-6)}`);
-    }
+    log(`budget recipient request key: ${agentJkt.slice(0, 8)}…${agentJkt.slice(-6)}`);
     openUrl(approveUrl);
     let lastHeartbeat = now();
     // Keep the event loop alive for the whole poll wait. `defaultSleep` unref()'s
@@ -270,33 +265,29 @@ export async function runHostedApproval(opts) {
                         }
                     }
                     // A budget approval must complete AS a budget approval — a relay that
-                    // dropped the flag would mint a single-purchase token that then rejects
-                    // the first sub-ceiling draw. Compare the boolean explicitly (it is not a
-                    // string, so it lives outside the string-map loop above).
-                    if (Boolean(doc.context?.budget) !== Boolean(budget)) {
+                    // dropped the flag did not complete OUR registration. Compare the
+                    // boolean explicitly (it is not a string, so it lives outside the
+                    // string-map loop above).
+                    if (doc.context?.budget !== true) {
                         throw new Error('hosted approval context mismatch on budget — the approval was not for this ' +
                             'exact purchase; run the checkout again for a fresh link');
                     }
-                    if (budget && doc.context?.agentJkt !== agentJkt) {
+                    if (doc.context?.agentJkt !== agentJkt) {
                         throw new Error('hosted approval context mismatch on agentJkt — the approval was not for this ' +
                             'exact request key; run the checkout again for a fresh link');
                     }
-                    if (!budget && doc.context?.agentJkt !== undefined) {
-                        throw new Error('hosted approval unexpectedly carried an agentJkt for a one-purchase request');
-                    }
-                    // The advisory draw ceiling must survive the relay intact too — a relay
-                    // that dropped or altered maxDraws would mint a budget token whose draw
-                    // count no longer matches what the operator approved. Only the budget
-                    // path registers maxDraws, so only enforce it there; compare exactly,
+                    // The draw ceiling must survive the relay intact too — a relay that
+                    // dropped or altered maxDraws would mint a budget token whose draw
+                    // count no longer matches what the operator approved. Compare exactly,
                     // the omitted/undefined case included, so a silently dropped value is
                     // caught the same as a mutated one.
-                    if (budget && doc.context?.maxDraws !== maxDraws) {
+                    if (doc.context?.maxDraws !== maxDraws) {
                         throw new Error('hosted approval context mismatch on maxDraws — the approval was not for this ' +
                             'exact purchase; run the checkout again for a fresh link');
                     }
                     // Same drop-or-mutate rule for the per-purchase cap: the term the
                     // operator read must be the term the token enforces.
-                    if (budget && doc.context?.perTransaction !== perTransaction) {
+                    if (doc.context?.perTransaction !== perTransaction) {
                         throw new Error('hosted approval context mismatch on perTransaction — the approval was not for ' +
                             'this exact purchase; run the checkout again for a fresh link');
                     }
@@ -306,14 +297,9 @@ export async function runHostedApproval(opts) {
                         throw new Error('hosted approval context mismatch on intent — the approval was not for this ' +
                             'exact purchase; run the checkout again for a fresh link');
                     }
-                    if (budget) {
-                        if (!Number.isSafeInteger(doc.validUntil) ||
-                            doc.validUntil <= Math.floor(now() / 1000)) {
-                            throw new Error('hosted budget approval completed without a valid future expiry');
-                        }
-                    }
-                    else if (doc.validUntil !== undefined) {
-                        throw new Error('hosted one-purchase approval unexpectedly carried a budget expiry');
+                    if (!Number.isSafeInteger(doc.validUntil) ||
+                        doc.validUntil <= Math.floor(now() / 1000)) {
+                        throw new Error('hosted budget approval completed without a valid future expiry');
                     }
                     log(assuranceExempt
                         ? 'approval received from the hosted page (code-verified card, no passkey).'
@@ -324,7 +310,7 @@ export async function runHostedApproval(opts) {
                         ...(typeof doc.mintToken === 'string' && doc.mintToken
                             ? { mintToken: doc.mintToken }
                             : {}),
-                        ...(budget ? { validUntil: doc.validUntil } : {}),
+                        validUntil: doc.validUntil,
                     };
                 }
                 // status 'pending' — the operator is still signing in / tapping.

package/dist/checkout-engine/mandate/card-mandate.js

@@ -18,7 +18,7 @@
 // stays FAIL-CLEAN as defense-in-depth: the budget is decremented only after a
 // payable cryptogram returns; a network rejection leaves the budget untouched.
 // The caller (cli-engine) then marks the mandate unhonored so the NEXT
-// pay_merchant skips it and takes a fresh per-purchase tap — the same call is
+// pay_merchant skips it and surfaces the no-covering refusal (#7348) — the same call is
 // not retried in-flight. Never fail-open.
 import { decimalToMinor, minorToDecimal, validateCredential, } from '../vgs-live-instrument.js';
 import { CARD_MANDATE_LEDGER_VERSION, remainingMinor, } from './mandate-ledger.js';

package/dist/checkout-engine/mandate/mandate-ledger.d.ts

@@ -47,7 +47,7 @@ export type CardMandateRecord = {
      * ceiling-scoped assurance the acquirer would not honor for a sub-amount
      * draw). Distinct from a reservation `status`: it disables the whole mandate.
      * Once set, findCovering() SKIPS this mandate so the caller's next
-     * pay_merchant falls through to a fresh per-purchase tap instead of
+     * pay_merchant surfaces the no-covering-mandate refusal (#7348) instead of
      * re-selecting the same failing mandate forever. ISO 8601.
      */
     unhonoredAt?: string;
@@ -55,8 +55,8 @@ export type CardMandateRecord = {
      * Set when the delegated-draw register handshake FAILED at mandate-start (the
      * server-side `card_mandate_spend` row was never created), so a later
      * delegated (verdict-signed) draw would 404 `no_mandate`. Like `unhonoredAt`,
-     * findCovering() SKIPS a register-failed mandate so the next checkout falls
-     * through to a fresh per-purchase tap instead of surfacing a confusing
+     * findCovering() SKIPS a register-failed mandate so the next checkout
+     * surfaces the no-covering-mandate refusal (#7348) instead of a confusing
      * `no_mandate`. Mandate-start requires delegated card authority, so every
      * created record attempted registration. ISO 8601.
      */
@@ -109,7 +109,7 @@ export declare class MandateLedger {
     /**
      * First ACTIVE mandate (not expired) whose merchant + currency match and whose
      * remaining headroom covers amountMinor. Used by pay_merchant to decide the
-     * tap-free draw path vs a fresh per-purchase tap.
+     * tap-free draw path vs the no-covering-mandate refusal (#7348).
      */
     findCovering(query: CoverQuery): Promise<CardMandateRecord | null>;
     /**

package/dist/checkout-engine/mandate/mandate-ledger.js

@@ -174,7 +174,7 @@ export class MandateLedger {
     /**
      * First ACTIVE mandate (not expired) whose merchant + currency match and whose
      * remaining headroom covers amountMinor. Used by pay_merchant to decide the
-     * tap-free draw path vs a fresh per-purchase tap.
+     * tap-free draw path vs the no-covering-mandate refusal (#7348).
      */
     async findCovering(query) {
         const now = query.now ?? new Date();
@@ -184,7 +184,7 @@ export class MandateLedger {
         // mandate the network refused is skipped via `!m.unhonoredAt` so it can never
         // be re-selected. A register-failed mandate is skipped the same way
         // (`!m.registerFailedAt`): it has no server row, so a delegated draw would 404
-        // `no_mandate` — better to fall through to a fresh per-purchase tap.
+        // `no_mandate` — better to surface the no-covering refusal (#7348).
         // Selection order among covering candidates:
         //   1. Prefer a merchant-SCOPED mandate over a crossMerchant budget one —
         //      spend the dedicated grant for this merchant first and keep the broader

package/dist/checkout-engine/vgs-gateway/server-mint-client.d.ts

@@ -37,13 +37,13 @@ export declare class ServerCryptogramRefusedError extends Error {
     constructor(status: number, detail: string);
 }
 /**
- * Optional mandate override for serverCreateIntent. Absent → the historical
- * 1:1 fresh-tap shape is preserved byte-for-byte (cap = ceil(amount)+10 min 25,
- * quantity 1, 30-day window). Present → the card-mandate (budget) layer sets a
- * CEILING decline threshold and a multi-draw quantity so one passkey approves a
- * spend ceiling and later draws pull cryptograms under it without a fresh tap.
- * Whether the network honors a ceiling-scoped assurance across multiple
- * sub-amount draws is UNPROVEN — see packages/checkout-engine/src/mandate/.
+ * Optional mandate override for serverCreateIntent. Absent → the default
+ * intent shape (cap = ceil(amount)+10 min 25, quantity 1, 30-day window).
+ * Present → the card-mandate (budget) layer sets a CEILING decline threshold
+ * and a multi-draw quantity so one passkey approves a spend ceiling and later
+ * draws pull cryptograms under it without a fresh tap. Whether the network
+ * honors a ceiling-scoped assurance across multiple sub-amount draws is
+ * UNPROVEN — see packages/checkout-engine/src/mandate/.
  */
 export type ServerIntentMandateOverride = {
     /** Wire decline-threshold amount (major-unit decimal string), e.g. "500.00". */

package/dist/checkout-engine/vgs-live-instrument.d.ts

@@ -80,14 +80,6 @@ export type FetchVgsPaymentCredential = (input: {
         transactionCurrencyCode: string;
     };
 }) => Promise<VgsPaymentCredential>;
-export type MintFreshVgsPaymentCredential = (input: {
-    tokenId: string;
-    assuranceData: unknown;
-    transaction: VgsCheckoutTarget;
-}) => Promise<{
-    payment: VgsPaymentCredential;
-    intentId: string;
-}>;
 /** The (token, intent) pair a VIC confirmation is posted against. */
 export type VicConfirmationTarget = {
     tokenId: string;
@@ -150,30 +142,3 @@ export declare class VgsLiveInstrument implements Instrument {
     confirmationTarget(): VicConfirmationTarget | null;
     getCredential(ctx: InstrumentContext): Promise<CardCredential>;
 }
-/**
- * Consumes #5614's claimed CLI enrollment artifact (for the tokenId) plus a
- * FRESH purchase-scoped assurance, and creates a fresh, transaction-scoped VIC
- * intent + credential after checkout approval. This is the production-shaped
- * bridge; unlike VgsLiveInstrument it never needs a pre-created intent ID.
- *
- * The enrollment artifact's stored assuranceData is deliberately never sent:
- * replaying it makes intent creation succeed (HTTP 201) while the cryptogram
- * deterministically never completes — the #5709 dead end. Purchase
- * authorization is the fresh, merchant+amount+currency-scoped assurance,
- * validated against the checkout target BEFORE any intent is minted so a
- * doomed intent is never created.
- */
-export declare class VgsAssuranceInstrument implements Instrument {
-    private readonly enrollment;
-    private readonly purchase;
-    private readonly target;
-    private readonly cardholderName;
-    private readonly mintCredential;
-    readonly kind: "agentic-token";
-    private used;
-    private minted;
-    constructor(enrollment: CliAgentCredential, purchase: PurchaseAssurance, target: VgsCheckoutTarget, cardholderName: string, mintCredential: MintFreshVgsPaymentCredential);
-    /** See VgsLiveInstrument.confirmationTarget — same contract. */
-    confirmationTarget(): VicConfirmationTarget | null;
-    getCredential(ctx: InstrumentContext): Promise<CardCredential>;
-}

package/dist/checkout-engine/vgs-live-instrument.js

@@ -87,13 +87,6 @@ function validateTarget(reference, ctx) {
         throw new Error(`VGS credential currency mismatch: ${currency} vs ${ctx.currency}`);
     }
 }
-function validateCliCredential(value) {
-    if (typeof value.tokenId !== 'string' || !value.tokenId.trim()) {
-        throw new Error('CLI agent credential requires tokenId');
-    }
-    // Deliberately no assuranceData requirement: the artifact's enrollment-time
-    // assurance is identity/enrollment material and is never read here (#5709).
-}
 /**
  * Refuse to mint an intent unless the assurance is fresh and its declared
  * scope matches the checkout target exactly. `now` is injectable so the
@@ -234,63 +227,3 @@ export class VgsLiveInstrument {
         };
     }
 }
-/**
- * Consumes #5614's claimed CLI enrollment artifact (for the tokenId) plus a
- * FRESH purchase-scoped assurance, and creates a fresh, transaction-scoped VIC
- * intent + credential after checkout approval. This is the production-shaped
- * bridge; unlike VgsLiveInstrument it never needs a pre-created intent ID.
- *
- * The enrollment artifact's stored assuranceData is deliberately never sent:
- * replaying it makes intent creation succeed (HTTP 201) while the cryptogram
- * deterministically never completes — the #5709 dead end. Purchase
- * authorization is the fresh, merchant+amount+currency-scoped assurance,
- * validated against the checkout target BEFORE any intent is minted so a
- * doomed intent is never created.
- */
-export class VgsAssuranceInstrument {
-    enrollment;
-    purchase;
-    target;
-    cardholderName;
-    mintCredential;
-    kind = 'agentic-token';
-    used = false;
-    minted = null;
-    constructor(enrollment, purchase, target, cardholderName, mintCredential) {
-        this.enrollment = enrollment;
-        this.purchase = purchase;
-        this.target = target;
-        this.cardholderName = cardholderName;
-        this.mintCredential = mintCredential;
-    }
-    /** See VgsLiveInstrument.confirmationTarget — same contract. */
-    confirmationTarget() {
-        return this.minted;
-    }
-    async getCredential(ctx) {
-        if (this.used)
-            throw new Error('VGS assurance instrument is single-use');
-        this.used = true;
-        validateCliCredential(this.enrollment);
-        validateTarget(this.target, ctx);
-        validatePurchaseAssurance(this.purchase, this.target);
-        if (!this.cardholderName.trim())
-            throw new Error('cardholder name is required');
-        const { payment: value, intentId } = await this.mintCredential({
-            tokenId: this.enrollment.tokenId,
-            assuranceData: this.purchase.assuranceData,
-            transaction: this.target,
-        });
-        this.minted = { tokenId: this.enrollment.tokenId, intentId };
-        validateCredential(value);
-        return {
-            pan: value.networkToken,
-            expMonth: value.expMonth,
-            expYear: value.expYear,
-            cvc: value.cryptogramValue,
-            cardholderName: this.cardholderName.trim(),
-            ...(value.cryptogramExpiresAt ? { credentialExpiresAt: value.cryptogramExpiresAt } : {}),
-            ...traceHandleFields(value),
-        };
-    }
-}