@agent-cards/sdk 0.23.19 → 0.23.20

package/dist/paddle-vgs.generated.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 // Generated from @agent-cards/payment-core. Do not edit.
-// artifact-sha256: f3437a15e11b72b9958179cc9610fdafb411cc5db76be536af62c08360a45575
+// artifact-sha256: 20dc16205adc94410b425b342c7c54fce24ec95960fb8a0ee2a1558ba9d96dea
 // src/paddle-vgs.js
 var PADDLE_VGS_PSP = "paddle_vgs";
 var PADDLE_VGS_CAPABILITY = "paddle_vgs_cards";
@@ -135,6 +135,7 @@ var pin = (fields) => Object.freeze({
     origins: Object.freeze([...fields.origins]),
     sellerClaim: fields.sellerClaim ? Object.freeze({ ...fields.sellerClaim }) : null
 });
+var PADDLE_VGS_ANY_SELLER = true;
 var PADDLE_VGS_MERCHANT_PINS = /* @__PURE__ */ Object.freeze([
     pin({ id: "rectangle_pro", merchant: "Rectangle Pro", origins: ["https://rectangleapp.com"], sellerClaim: null })
 ]);
@@ -143,14 +144,17 @@ function paddleVgsMerchantPin(merchantOrigin, pins = PADDLE_VGS_MERCHANT_PINS) {
         return null;
     return pins.find((entry) => !!entry && Array.isArray(entry.origins) && entry.origins.includes(merchantOrigin)) ?? null;
 }
-function paddleVgsMerchantRefusal(environment, merchantOrigin, authorization, pins = PADDLE_VGS_MERCHANT_PINS) {
+var SELLER_ORIGIN = /^https:\/\/(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+var SELLER_ORIGIN_LIMIT = 261;
+function paddleVgsMerchantRefusal(environment, merchantOrigin, authorization, pins = PADDLE_VGS_MERCHANT_PINS, anySeller = PADDLE_VGS_ANY_SELLER) {
     if (environment === "sandbox")
         return null;
     if (environment !== "production")
         return "unsupported_environment";
     const found = paddleVgsMerchantPin(merchantOrigin, pins);
-    if (!found)
-        return "paddle_vgs_merchant_unreviewed";
+    if (!found) {
+        return anySeller === true && typeof merchantOrigin === "string" && merchantOrigin.length <= SELLER_ORIGIN_LIMIT && SELLER_ORIGIN.test(merchantOrigin) ? null : "paddle_vgs_merchant_unreviewed";
+    }
     if (found.sellerClaim && authorization !== void 0) {
         const claims = bearerClaims(authorization);
         if (!claims || claims[found.sellerClaim.name] !== found.sellerClaim.value)
@@ -405,4 +409,4 @@ function paddleVgsPayVerdict(request, approved) {
         card.metadata[key] = facts[key];
     return Object.freeze({ verdict: "continue", body: JSON.stringify(value) });
 }
-export { PADDLE_VGS_CAPABILITY, PADDLE_VGS_CARDS_URLS, PADDLE_VGS_CARD_ID_WINDOW_MS, PADDLE_VGS_CARD_NETWORKS, PADDLE_VGS_CONTENT_TYPE, PADDLE_VGS_MERCHANT_PINS, PADDLE_VGS_OPERATION, PADDLE_VGS_PSP, PADDLE_VGS_REFUSAL_CODES, injectPaddleVgsCard, isPaddleVgsCardsUrl, isPreparedPaddleVgsRequest, paddleVgsAnswerOutcome, paddleVgsBodyVerdict, paddleVgsCardFacts, paddleVgsCardFactsAgree, paddleVgsCardFactsOf, paddleVgsCardRefusal, paddleVgsEnvironment, paddleVgsMerchantPin, paddleVgsMerchantRefusal, paddleVgsPayCarriesStoredCard, paddleVgsPayTarget, paddleVgsPayVerdict, paddleVgsRefusalCode, paddleVgsRefusalMessage, paddleVgsRequestRefusal, paddleVgsSellerClaimsPinned, paddleVgsStoredCardRefusal, paddleVgsTypedCardRefusal };
+export { PADDLE_VGS_ANY_SELLER, PADDLE_VGS_CAPABILITY, PADDLE_VGS_CARDS_URLS, PADDLE_VGS_CARD_ID_WINDOW_MS, PADDLE_VGS_CARD_NETWORKS, PADDLE_VGS_CONTENT_TYPE, PADDLE_VGS_MERCHANT_PINS, PADDLE_VGS_OPERATION, PADDLE_VGS_PSP, PADDLE_VGS_REFUSAL_CODES, injectPaddleVgsCard, isPaddleVgsCardsUrl, isPreparedPaddleVgsRequest, paddleVgsAnswerOutcome, paddleVgsBodyVerdict, paddleVgsCardFacts, paddleVgsCardFactsAgree, paddleVgsCardFactsOf, paddleVgsCardRefusal, paddleVgsEnvironment, paddleVgsMerchantPin, paddleVgsMerchantRefusal, paddleVgsPayCarriesStoredCard, paddleVgsPayTarget, paddleVgsPayVerdict, paddleVgsRefusalCode, paddleVgsRefusalMessage, paddleVgsRequestRefusal, paddleVgsSellerClaimsPinned, paddleVgsStoredCardRefusal, paddleVgsTypedCardRefusal };

package/dist/pre-claim.d.ts

@@ -99,6 +99,8 @@ export interface PreClaimContext {
         verifoneProfileOf?(url: string): VerifoneProfile | null;
         cardOnFilePolicy?(url: string, method?: string): string | null;
         withoutCard?(url: string, body: string | null | undefined): 'continue' | 'refuse' | null;
+        /** VaultClient.recognizesProcessor: whether the synced registry serves this processor. */
+        recognizesProcessor?(psp: string): boolean;
         /** VaultClient.sendEbanxFollowUp: a send an approved EBANX token request covers, from the cardholder's device. */
         sendEbanxFollowUp?(authorizationId: string, request: {
             url: string;
@@ -251,11 +253,23 @@ export declare function isArmedCreditguardCall(vault: {
 } | undefined, url: string): boolean;
 export declare const ekashuPreClaim: PreClaimGate;
 export declare const redsysPreClaim: PreClaimGate;
+export declare const quickpayPreClaim: PreClaimGate;
 export declare const paypalHostedFieldsPreClaim: PreClaimGate;
 export declare const paypalCardFormsPreClaim: PreClaimGate;
 export declare const cybersourceSecureAcceptancePreClaim: PreClaimGate;
 export declare const worldlineMyCheckoutPreClaim: PreClaimGate;
 export declare const paddleVgsPayPreClaim: PreClaimGate;
+export type HipayPreClaimRefusal = 'hipay_number_only' | 'hipay_update_refused';
+export declare const hipayPreClaim: PreClaimGate;
+/**
+ * Whether attachToPlaywright routes `url` to the gates for HiPay: any request to HiPay's two vault hosts, once the
+ * synced registry serves HiPay, as attachToCdp arms both hosts from the recognizer. Playwright's route matcher sees
+ * only the URL and the recognizer takes the token create alone, so without this /update would never reach
+ * hipayPreClaim there. Any other request to those hosts goes on untouched.
+ */
+export declare function routesHipayVault(vault: {
+    recognizesProcessor?: (psp: string) => boolean;
+} | null | undefined, url: string): boolean;
 export declare const ebanxPreClaim: PreClaimGate;
 /** The processor gates, in order. A new family adds one entry here; the terminal
  * arbiter runs after all of them and is not part of this list. A gate appended

package/dist/pre-claim.js

@@ -80,11 +80,13 @@ import { PAYRAILS_HOLDING_REASONS, PAYRAILS_SESSION_MESSAGE, isPayrailsHost, isP
 import { classifyVerifoneProfileRequest, verifoneTemplatedUrl } from './verifone.js';
 import { ekashuEntryUrl, isEkashuEntry, isEkashuHost } from './ekashu.js';
 import { isRedsysEntry, isRedsysHost, redsysEntryUrl } from './redsys.js';
+import { isQuickpayCardLookup, isQuickpayEntry, quickpayEntryUrl } from './quickpay.js';
 import { PAYPAL_HOSTED_FIELDS_REASON, isPaypalHostedFieldsConfirm, paypalHostedFieldsBody } from './paypal-hosted-fields.js';
 import { PAYPAL_CARD_FIELDS_REASON, PAYPAL_GUEST_CHECKOUT_REASON, isPaypalCardFieldsConfirm, isPaypalGraphql, paypalCardFieldsBody, paypalGraphqlCard, paypalGraphqlNamesCardOperation, } from './paypal-card-forms.js';
 import { CYBERSOURCE_SECURE_ACCEPTANCE_REASON, CYBERSOURCE_SECURE_ACCEPTANCE_RECIPIENT, cybersourceSecureAcceptanceRequest, isCybersourceSecureAcceptanceUrl, isSecureAcceptanceFramePost, } from './cybersource-secure-acceptance.js';
 import { isWorldlineMyCheckoutEndpoint } from './worldline-mycheckout.js';
 import { paddleVgsPayEventUrl } from './paddle-vgs-pay.js';
+import { HIPAY_PSP, HIPAY_TOKEN_URLS, HIPAY_UPDATE_PATH, HIPAY_VAULT_HOSTS, hipayNumberOnlyRequest } from './hipay.generated.js';
 import { EBANX_RESEND_REASON, EbanxFollowUpError, ebanxResendRefusalOf, isEbanxResendUrl, } from './ebanx.js';
 /**
  * The URL an event may name for a request. For an armed merchant profile's
@@ -1595,7 +1597,8 @@ export const ekashuPreClaim = (ctx) => {
         return undefined;
     return processorPageAbort(ctx);
 };
-// The stop for a card post into a processor's own page that only the cardholder's device may pay (NMI's, Redsys's).
+// The stop for a card post into a processor's own page that only the cardholder's device may pay (NMI's, Redsys's,
+// QuickPay's).
 async function processorPageAbort(ctx) {
     const { url, method } = ctx.request;
     ctx.preparationGate.invalidate('unsupported_checkout');
@@ -1628,6 +1631,30 @@ export const redsysPreClaim = (ctx) => {
         return undefined;
     return processorPageAbort(ctx);
 };
+// QuickPay's hosted payment window (quickpay.ts). Once this build's registry serves QuickPay's entry (a capability
+// the API serves only to a company Agentcard turned QuickPay on for), every request to QuickPay's host pauses, and
+// this gate judges the POSTs and the window's card lookup:
+//   - the merchant's entry (the host's root, no query) defers, and the terminal arbiter pauses it for the claim
+//     flow like any card request: the cardholder's device pays it;
+//   - every other POST to QuickPay (the window's card post, its fee lookup, its wallet token post, its 3-D Secure
+//     step, and the framed twin of the entry, whose window asks for a card) aborts as an unsupported checkout,
+//     and so does the window's GET that looks up the typed card's first digits, so QuickPay never sees the card
+//     the agent typed. The agent's browser only reaches QuickPay's window when the entry was not paused (an
+//     attachment made too late, say), and then only the cardholder's device can pay.
+// Any other GET (the window itself, its scripts and images) is not this gate's and continues. With QuickPay not
+// served, the entry is no card request, the gate defers, and every request continues as before. Synchronous
+// until it must abort, like every gate. Exported for the gate registry's tests.
+export const quickpayPreClaim = (ctx) => {
+    const { url, method } = ctx.request;
+    if (String(method).toUpperCase() !== 'POST' && !isQuickpayCardLookup(url, method))
+        return undefined;
+    const entry = quickpayEntryUrl(url);
+    if (!entry || !ctx.vault.isCardRequest(entry, 'POST'))
+        return undefined;
+    if (isQuickpayEntry(url, method))
+        return undefined;
+    return processorPageAbort(ctx);
+};
 // PayPal's legacy Hosted Fields (paypal-hosted-fields.ts). Its tokenization frame posts the card the
 // agent typed to the Orders v2 confirm-payment-source on cors.api.paypal.com (or its sandbox), which
 // no Vault mode takes over, so every company's adapters hand each POST there to this gate:
@@ -1952,6 +1979,52 @@ async function paddleVgsPayContinued(ctx, body) {
             fields: ['card_first_six', 'card_last_four', 'expiry_month', 'expiry_year', 'card_brand'] } });
     return { kind: 'continue' };
 }
+// HiPay's hosted fields (payment-core hipay.js). The controller frame posts the card number alone as soon as the typed
+// number is valid, before Pay, and posts /rest/v2/token/update with a token once it holds one. Neither is this lane's
+// card request. The number-only post fails here as a network error, so the frame keeps the number and Pay sends one
+// complete create, the request a preparation binds. /update fails the same way, so the page's placeholder code and
+// expiry never ride under a token HiPay minted for the real card (the frame holds one only when an answer reached it
+// after the page gave up). Both fail before the preparation claim reads them: a ready preparation is neither spent
+// nor invalidated, and nothing reaches the API. Only while the synced registry serves HiPay (a build that declared
+// hipay_vault_token, for a company Agentcard turned HiPay on for); for anyone else HiPay's traffic is left as it was.
+const HIPAY_UPDATE_URLS = Object.values(HIPAY_TOKEN_URLS).map((url) => `${new URL(url).origin}${HIPAY_UPDATE_PATH}`);
+export const hipayPreClaim = (ctx) => {
+    const { url, method } = ctx.request;
+    if (typeof method !== 'string' || method.toUpperCase() !== 'POST' || ctx.vault.recognizesProcessor?.(HIPAY_PSP) !== true)
+        return undefined;
+    if (HIPAY_UPDATE_URLS.includes(url))
+        return hipayRefused(ctx, 'hipay_update_refused');
+    let body;
+    // A reader that throws (Playwright's postData() can) proves nothing: the request is judged later, as any other.
+    try {
+        body = ctx.request.body;
+    }
+    catch {
+        return undefined;
+    }
+    return hipayNumberOnlyRequest(url, method, body) ? hipayRefused(ctx, 'hipay_number_only') : undefined;
+};
+/**
+ * Whether attachToPlaywright routes `url` to the gates for HiPay: any request to HiPay's two vault hosts, once the
+ * synced registry serves HiPay, as attachToCdp arms both hosts from the recognizer. Playwright's route matcher sees
+ * only the URL and the recognizer takes the token create alone, so without this /update would never reach
+ * hipayPreClaim there. Any other request to those hosts goes on untouched.
+ */
+export function routesHipayVault(vault, url) {
+    let host;
+    try {
+        host = new URL(url).hostname;
+    }
+    catch {
+        return false;
+    }
+    return Object.keys(HIPAY_VAULT_HOSTS).includes(host) && vault?.recognizesProcessor?.(HIPAY_PSP) === true;
+}
+async function hipayRefused(ctx, reason) {
+    ctx.onEvent?.({ type: 'blocked', detail: reason });
+    await ctx.effects.abort();
+    return { kind: 'abort' };
+}
 // EBANX after its card token (ebanx.ts, payment-core ebanx.js). Once the cardholder's device has sent the card to
 // /ws/token, EBANX's hosted payment page and EBANX.js send the card the page holds again: its 3-D Secure calls post
 // the card, and the hosted page's confirm posts its code beside EBANX's token. On a page this SDK is attached to that
@@ -2147,8 +2220,8 @@ async function unsupportedContinue(ctx) {
  * arbiter runs after all of them and is not part of this list. A gate appended
  * after Stripe is never offered a step Stripe claimed: Stripe answers, aborts or
  * pauses each one itself. */
-export const PSP_PRE_CLAIM_GATES = [cardEndpointResendPreClaim, cardEndpointPreClaim, mercadoPreClaim, juspayPreClaim, braintreePreClaim, stripePreClaim, merchantHostedPreClaim, verifonePreClaim, fiservPreClaim, gmoPreClaim, cybersourceFlexPreClaim, datatransPreClaim, pelecardPreClaim, aciPreClaim, creditguardPreClaim, primerPreClaim, payrailsPreClaim, convergePreClaim, eprotectPreClaim, wspayPreClaim, shijiStsPreClaim, ekashuPreClaim, redsysPreClaim, paypalHostedFieldsPreClaim,
-    paypalCardFormsPreClaim, cybersourceSecureAcceptancePreClaim, worldlineMyCheckoutPreClaim, paddleVgsPayPreClaim, ebanxPreClaim];
+export const PSP_PRE_CLAIM_GATES = [cardEndpointResendPreClaim, cardEndpointPreClaim, mercadoPreClaim, juspayPreClaim, braintreePreClaim, stripePreClaim, merchantHostedPreClaim, verifonePreClaim, fiservPreClaim, gmoPreClaim, cybersourceFlexPreClaim, datatransPreClaim, pelecardPreClaim, aciPreClaim, creditguardPreClaim, primerPreClaim, payrailsPreClaim, convergePreClaim, eprotectPreClaim, wspayPreClaim, shijiStsPreClaim, ekashuPreClaim, redsysPreClaim, quickpayPreClaim, paypalHostedFieldsPreClaim,
+    paypalCardFormsPreClaim, cybersourceSecureAcceptancePreClaim, worldlineMyCheckoutPreClaim, paddleVgsPayPreClaim, ebanxPreClaim, hipayPreClaim];
 /** Run each gate in order; the first to return a decision wins. If none does,
  * the terminal arbiter decides between continue, abort (unsupported) and pause.
  * Returns synchronously while every gate defers synchronously (an ordinary card

package/dist/prepared-processor.d.ts

@@ -24,8 +24,12 @@
  * wix_payments: prepared only. Wix's payment widget fails the payment 30 seconds after it asks Wix
  * Cashier's card frame for a token, too soon for an approval after Pay. Its one environment is
  * production: Wix's tokenizer has no test host.
+ *
+ * hipay: prepared only. The merchant's page gives HiPay's hosted fields 20 seconds after Pay, too soon for an
+ * approval after Pay. Its environments are its two vault hosts: secure2-vault (production) and
+ * stage-secure2-vault (sandbox).
  */
-export type PreparationProcessor = 'square' | 'braintree' | 'worldpay' | 'bambora' | 'mercado_pago' | 'recurly' | 'spreedly' | 'adyen' | 'checkout_com' | 'paysafe' | 'fiserv' | 'cybersource_flex' | 'aci' | 'creditguard' | 'worldpay_eprotect' | 'amadeus_checkout' | 'verifone' | 'cybersource_secure_acceptance' | 'paddle_vgs' | 'wix_payments';
+export type PreparationProcessor = 'square' | 'braintree' | 'worldpay' | 'bambora' | 'mercado_pago' | 'recurly' | 'spreedly' | 'adyen' | 'checkout_com' | 'paysafe' | 'fiserv' | 'cybersource_flex' | 'aci' | 'creditguard' | 'worldpay_eprotect' | 'amadeus_checkout' | 'verifone' | 'cybersource_secure_acceptance' | 'paddle_vgs' | 'wix_payments' | 'hipay';
 export type PreparationEnvironment = 'production' | 'sandbox' | 'shared';
 /**
  * How the approved card reaches the processor: the device's own request (token), or
@@ -62,7 +66,7 @@ export declare function preparedApprovalAnswersRetry(psp: string): boolean;
  * its own signing keys. A Verifone preparation pays in the environment of the key its reviewed
  * profile pins. CyberSource Secure Acceptance's are separate hosts too: secureacceptance is
  * live, testsecureacceptance is test. So are Paddle VGS's two card URLs: vault is live,
- * sandbox-vault is test.
+ * sandbox-vault is test. So are HiPay's two vault hosts: secure2-vault is live, stage-secure2-vault is test.
  */
 export declare function validPreparationEnvironment(psp: string, environment: string): boolean;
 /**

package/dist/prepared-processor.js

@@ -15,6 +15,7 @@ import { isPreparedVerifoneRequest } from './verifone.js';
 import { isPreparedSecureAcceptanceRequest, secureAcceptanceEnvironment, secureAcceptancePreparationUrl, secureAcceptanceRequestRefusal, } from './cybersource-secure-acceptance.generated.js';
 import { PADDLE_VGS_CARDS_URLS, isPreparedPaddleVgsRequest } from './paddle-vgs.generated.js';
 import { WIX_PAYMENTS_TOKENIZE_URL, isPreparedWixPaymentsRequest } from './wix-payments.generated.js';
+import { HIPAY_TOKEN_URLS, hipayRequestRefusal, hipayTokenEnvironment, isPreparedHipayRequest } from './hipay.generated.js';
 export function preparationMode(psp) {
     return psp === 'adyen' || psp === 'fiserv' || psp === 'verifone' ? 'cse' : 'token';
 }
@@ -49,7 +50,7 @@ export function preparedApprovalAnswersRetry(psp) {
  * its own signing keys. A Verifone preparation pays in the environment of the key its reviewed
  * profile pins. CyberSource Secure Acceptance's are separate hosts too: secureacceptance is
  * live, testsecureacceptance is test. So are Paddle VGS's two card URLs: vault is live,
- * sandbox-vault is test.
+ * sandbox-vault is test. So are HiPay's two vault hosts: secure2-vault is live, stage-secure2-vault is test.
  */
 export function validPreparationEnvironment(psp, environment) {
     if (psp === 'bambora' || psp === 'mercado_pago' || psp === 'recurly' || psp === 'spreedly')
@@ -58,7 +59,7 @@ export function validPreparationEnvironment(psp, environment) {
     if (psp === 'wix_payments')
         return environment === 'production';
     return ['square', 'braintree', 'worldpay', 'adyen', 'checkout_com', 'paysafe', 'fiserv', 'cybersource_flex', 'aci', 'creditguard', 'worldpay_eprotect', 'amadeus_checkout', 'verifone',
-        'cybersource_secure_acceptance', 'paddle_vgs'].includes(psp) && ['production', 'sandbox'].includes(environment);
+        'cybersource_secure_acceptance', 'paddle_vgs', 'hipay'].includes(psp) && ['production', 'sandbox'].includes(environment);
 }
 /**
  * ACI's prepared endpoint, the literal the API names (backend checkout-prepared-processor.ts): its
@@ -106,6 +107,9 @@ export function preparationEndpoint(psp, environment) {
     // Wix Payments: the tokenize URL, the only URL the claim takes for it.
     if (psp === 'wix_payments')
         return WIX_PAYMENTS_TOKENIZE_URL;
+    // HiPay: the token create on the environment's vault, the only URL the claim takes for it.
+    if (psp === 'hipay')
+        return HIPAY_TOKEN_URLS[environment];
     // A Verifone endpoint is its reviewed profile's leg, never one per environment (verifone.ts).
     if (psp === 'verifone')
         throw new Error('unsupported_preparation_processor');
@@ -263,6 +267,11 @@ export function matchesPreparedRequest(psp, environment, requestUrl, method, bod
     // site's app instance and the card frame's body), the rule the API and the Vault bind with too.
     if (psp === 'wix_payments')
         return isPreparedWixPaymentsRequest(requestUrl, method.toUpperCase(), body ?? null, environment, headers ?? {});
+    // HiPay: the environment's own vault and payment-core's whole request rule (a JSON content type, a public username of
+    // that environment and a complete create, never the hosted fields' number-only post), the rule the API and the Vault
+    // bind with too.
+    if (psp === 'hipay')
+        return isPreparedHipayRequest(requestUrl, method.toUpperCase(), body ?? null, environment, headers ?? {});
     if (psp === 'creditguard')
         return matchesPreparedCreditguard(environment, requestUrl, body, headers, binding);
     // A Verifone request is judged only through the profile its preparation names (matchesPreparation).
@@ -423,6 +432,13 @@ export function preparedRequestRefusal(psp, environment, requestUrl, body, heade
         const reason = secureAcceptanceClaimRefusal(requestUrl, body, headers, merchantOrigin, currency);
         return reason === null ? 'checkout_changed' : `secure_acceptance_${reason}`;
     }
+    // A HiPay token create on the prepared environment's vault names what payment-core's request rule refused
+    // (hipay_keeps_card, hipay_headers_refused, ...); another vault or another request is `checkout_changed`.
+    if (psp === 'hipay') {
+        if (hipayTokenEnvironment(requestUrl) !== environment)
+            return 'checkout_changed';
+        return hipayRequestRefusal({ url: requestUrl, method: 'POST', headers, body: body ?? null }) ?? 'checkout_changed';
+    }
     if (psp !== 'amadeus_checkout' || amadeusEnvironment(requestUrl) !== environment)
         return 'checkout_changed';
     const merchantHost = merchantHostOf(merchantOrigin);