@agent-cards/sdk 0.20.0 → 0.22.0

package/dist/eprotect.d.ts

@@ -0,0 +1,152 @@
+/** The processor id, as the registry and the API name it. */
+export declare const EPROTECT_PSP = "worldpay_eprotect";
+/** The dark-launch capability the API serves the eProtect recognizer behind (payment-core definitions.js). */
+export declare const EPROTECT_CAPABILITY = "worldpay_eprotect_jsonp";
+/** What Worldpay answers a registration with on both of its card hosts, and what the paused script gets. */
+export declare const EPROTECT_SCRIPT_CONTENT_TYPE = "application/x-javascript;charset=UTF-8";
+/** A reviewed production Worldpay merchant, as payment-core pins it (EPROTECT_MERCHANT_PINS). */
+export interface EprotectMerchantPin {
+    id: string;
+    merchant: string;
+    origins: readonly string[];
+    paypageIds: readonly string[];
+}
+/**
+ * Why a Worldpay eProtect checkout may not be prepared under `merchant`, or null when it may. On the
+ * production host the API admits only a paypageId payment-core pins for the merchant origin, under
+ * that pin's merchant name, the one the approval shows, and refuses another name
+ * (merchant_profile_mismatch) before any preparation exists. When this build pins the paypageId
+ * too, it refuses another name first, before any network call, as a Fiserv checkout must name its
+ * key pin's merchant. A paypageId this build does not pin is the API's to judge (unsupported_checkout
+ * with no pin); none is pinned on either side yet. The pre-live host takes only the guide's test
+ * cards and needs no pin. `pins` is for tests.
+ */
+export declare function eprotectCheckoutRefusal(input: {
+    environment: string;
+    paypageId: string;
+    merchantOrigin: string;
+    merchant: string;
+}, pins?: readonly EprotectMerchantPin[]): 'merchant_profile_mismatch' | null;
+/** The attempt a registration, a re-send or a give-up report belongs to: the merchant's paypageId and the page's own id. */
+export interface EprotectAttempt {
+    paypageId: string;
+    id: string;
+}
+/**
+ * What a request on Worldpay eProtect's hosts is, for an attachment:
+ *   registration  the vendor's new-card registration GET, the only card request;
+ *   failover      the vendor's re-send of a registration (targetServer=secondary);
+ *   give_up       the vendor's /eProtect/ppstats report that the merchant's timeout passed with no answer;
+ *   unsupported   any other request on /eProtect/paypage: a variant (CVV only, PIN, wallets, private
+ *                 label), the native-app Mobile API form post, another method or a malformed query;
+ *   sibling       everything else on those hosts: the scripts, the payframe, other ppstats reports.
+ */
+export type EprotectRequest = ({
+    kind: 'registration';
+} & EprotectAttempt) | ({
+    kind: 'failover';
+} & EprotectAttempt) | ({
+    kind: 'give_up';
+    code: '900' | '901';
+} & EprotectAttempt) | {
+    kind: 'unsupported';
+} | {
+    kind: 'sibling';
+};
+/** Which eProtect request this is, or null for a URL that is not on one of Worldpay eProtect's hosts. */
+export declare function classifyEprotectRequest(url: string, method: string): EprotectRequest | null;
+/** The registration GET exactly as payment-core admits it: its URL alone, with no body. */
+export declare function isEprotectRegistration(request: {
+    url: string;
+    method?: string;
+    body?: string | null;
+}): boolean;
+/**
+ * The answer a paused registration script gets, or null when the stored answer is not one to hand
+ * the page: Worldpay's own shape, `<callback>(<registration>)` under its script type, with the
+ * callback the paused URL named. The registration must be one payment-core's judge accepts for that
+ * exact URL (response 870, the page's own id, only allowlisted fields), byte for byte what the API
+ * stored after running the same judge.
+ */
+export declare function eprotectScriptAnswer(templateUrl: string, response: {
+    status: number;
+    body: string;
+}): {
+    status: 200;
+    headers: Record<string, string>;
+    body: string;
+} | null;
+/**
+ * How long a paused registration's re-send is still recognized as a known repeat. The vendor
+ * scripts re-send 5 seconds after an unanswered primary and give up at the merchant's own timeout
+ * (10 to 15 seconds at the merchants this SDK covers), so a minute leaves room for a timer a busy
+ * page delays. A re-send that comes later still is aborted all the same, as unsupported (pre-claim).
+ */
+export declare const EPROTECT_REPEAT_WINDOW_MS = 60000;
+/** At most this many paused registrations are remembered at once; the oldest is forgotten first. */
+export declare const EPROTECT_REPEAT_LIMIT = 64;
+/**
+ * One attachment's eProtect state. A failover re-send or a give-up report names a registration by
+ * paypageId and id; each is matched against what this attachment itself paused and answered, never
+ * taken on the page's word. Inert (classify returns null) until the registry serves eProtect, which
+ * a client reaches only by syncing with the capability for an org the API enabled, so a build, an
+ * org or an API that never served it leaves every eProtect request exactly as before.
+ */
+export declare class EprotectGate {
+    private readonly vault;
+    private readonly now;
+    /** Paused registrations, oldest first, each with the time its re-send window closes. */
+    private readonly seen;
+    private running;
+    private answered;
+    constructor(vault: {
+        recognizesProcessor?: (psp: string) => boolean;
+    } | undefined, now?: () => number);
+    /** What this request is, when the registry serves eProtect and the URL is on its hosts; null leaves it to the other gates. */
+    classify(url: string, method: string): EprotectRequest | null;
+    /** Playwright's route predicate sees only the URL: route the registration family and the give-up reports, never the scripts. */
+    matches(url: string): boolean;
+    /**
+     * The page sent this registration and this attachment paused it: its re-send is then a known
+     * repeat for EPROTECT_REPEAT_WINDOW_MS. Seeing it again restarts that window. A long-lived
+     * attachment keeps at most EPROTECT_REPEAT_LIMIT of them, so repeated attempts never grow it.
+     */
+    saw(attempt: EprotectAttempt): void;
+    /** Drops every registration whose re-send window closed: the map is in window order. */
+    private forgetBefore;
+    /**
+     * A re-send of a registration this attachment paused, whether its approval is running, answered,
+     * or never started. The vendor script re-sends 5 seconds after an unanswered primary and has no
+     * error path, so a primary the adapters refused before any approval (no ready preparation, another
+     * paypageId, an approval already outstanding) or answered just as that timer fired is re-sent
+     * too. Such a re-send is aborted quietly, like one during the approval, and never replaces that
+     * refusal's own state with `unsupported`. A re-send of a registration this attachment never paused
+     * means the primary went somewhere it does not cover, and pre-claim aborts that one as unsupported.
+     * Both carry the placeholder's ciphertext, and both are aborted. A registration is remembered
+     * only for its re-send window (saw).
+     */
+    repeats(attempt: EprotectAttempt): boolean;
+    /**
+     * An approval is running for this paused request, when it is a registration; `stop` ends it as the
+     * page abandoning its request. A new attempt also retires the last answered registration: a
+     * give-up report for it now belongs to a checkout the lifecycle has moved past, and must not end
+     * the attempt that just began (see gaveUp).
+     */
+    begin(url: string, method: string, stop: () => void): void;
+    /**
+     * The approval's answer reached this registration; `lost` reports that the page had already given
+     * up on it. Kept after the attempt ends, since the vendor's report can land just after the answer,
+     * and only until the next attempt begins.
+     */
+    delivered(url: string, lost: () => void): void;
+    /** The approval for the paused request ended, answered or not. */
+    end(): void;
+    /**
+     * The vendor's give-up report: end the approval still running for that registration (the
+     * adapter cancels the authorization, which the API confirms only before the device registered
+     * the card, and aborts the paused script instead of answering it), or report that the answer
+     * already handed to it came too late. Returns which one, or null when the report names neither,
+     * including a registration answered before the current attempt began.
+     */
+    gaveUp(attempt: EprotectAttempt): 'running' | 'answered' | null;
+}

package/dist/eprotect.generated.d.ts

@@ -0,0 +1,77 @@
+declare var EPROTECT_PATH: string;
+declare var EPROTECT_HOSTS: Readonly<{
+    production: "request.eprotect.vantivcnp.com";
+    sandbox: "request.eprotect.vantivprelive.com";
+}>;
+declare var EPROTECT_SECONDARY_HOST: string;
+declare var EPROTECT_KEYS: Readonly<{
+    production: Readonly<{
+        keyId: "26455500012";
+        exponent: "10001";
+        modulus: "b9c7095ff203475347a932a6e11bacbb61cfb66a877158683634e5fb1dbf9923401bd7f82c21b67ffd3c82bdc64797c5e2ba4b57c68b1aaccb7fbe847da7234a21df910dfcc0aebacbbd4d36b35c0c35f7ee27358610d2e2fb2aa87d359deda0b5f4d77e31ac5ab98741da5b6052cb657087da05ad496154b8954939ee6fd463301ff15ebca94f210f4627a255a95ca8833728c1ab80b6cc3a874e4d3dce5d40f66c043ba1b042717bb9cc5d89434fa489a51c2ba9a3843b310df58c9e8a54c36cdd5fd66e76651b6fc88850b60e0739abfcf7d0d0cb44beb7e768da3bcea7e743b8c2d57edef59643f54432ccf60c49d4f5f84410ecf9c5a7af19bc5e792801";
+    }>;
+    sandbox: Readonly<{
+        keyId: "1";
+        exponent: "10001";
+        modulus: "bc637dd74ba76507dad5af1c7ad6f97dbef5298c3b9f74caea7301347db7b4a8c37f26491863100667246fd45071f3346bf62239f9b117d06fb67861b66ad0d158beeddd2f6f28be93d846f4c8f9ba1bd7e8f186f36cab0e432f22b3d732c221a9ff00a9bfacb88b24503e2695fd7237835d4936477b21289478906a49b164f52503c20eb29f11fcbda2af94deb9a0bfde5a4589276897436315c5d664d60bf10650164f509283aed39747ad5d6cb2bbe54e1b42306e5db37dfd42dcbfcc689e0ddfe3bc9cb22ae7018e5a4a1ff39813584ac7bd6d6d65ca763f0a672da454081ea20e8b1d403316d80b9353ba396bea8962b1a7d2f775c76612d857c1f7594f";
+    }>;
+}>;
+declare var EPROTECT_TEST_PANS: Readonly<Set<unknown>>;
+declare var EPROTECT_REFUSAL_CODES: readonly string[];
+declare function eprotectEnvironment(hostname: any): "production" | "sandbox" | null;
+declare function eprotectPreparationUrl(environment: any): string;
+declare function isEprotectTokenRequest(url: any, method: any): boolean;
+declare function isEprotectRequest(request: any): boolean;
+declare function eprotectRequestFacts(url: any): {
+    environment: string;
+    paypageId: any;
+    id: any;
+    orderId: any;
+    reportGroup: any;
+    callback: any;
+    cvv: boolean;
+} | null;
+declare function eprotectSecondaryAttempt(url: any): {
+    paypageId: any;
+    id: any;
+} | null;
+declare function isEprotectDeviceRequest(templateUrl: any, deviceUrl: any): boolean;
+declare function isPreparedEprotectRequest(url: any, method: any, body: any, environment: any, paypageId: any): boolean;
+declare var EPROTECT_MERCHANT_PINS: any;
+declare function eprotectMerchantPin(paypageId: any, merchantOrigin: any, pins?: any): any;
+declare function eprotectMerchantRefusal(environment: any, paypageId: any, merchantOrigin: any, pins?: any): "invalid_paypage_id" | "unsupported_environment" | "eprotect_merchant_unreviewed" | null;
+declare function defaultRandom(bytes: any): void;
+declare function eprotectEncrypt(text: any, key: any, random?: typeof defaultRandom): string;
+declare function eprotectCardRefusal(environment: any, cardNumber: any): "unsupported_environment" | "sandbox_host_requires_documented_test_card" | "invalid_card_number" | "live_host_refuses_documented_test_card" | null;
+declare function eprotectDeviceRequest(templateUrl: any, card: any, random?: typeof defaultRandom): {
+    url: string;
+    method: string;
+    headers: {};
+    body: string;
+    where: string[];
+};
+declare function eprotectOutcome(status: any, bodyText: any, templateUrl: any, card: any): {
+    outcome: string;
+    reason: string;
+    code?: undefined;
+    sanitizedJson?: undefined;
+} | {
+    outcome: string;
+    code: any;
+    reason?: undefined;
+    sanitizedJson?: undefined;
+} | {
+    outcome: string;
+    sanitizedJson: string;
+    reason?: undefined;
+    code?: undefined;
+};
+declare function sanitizeEprotectRegistration(bodyText: any, templateUrl: any): string | undefined;
+declare function eprotectJsonp(callback: any, json: any): string;
+declare function eprotectGiveUp(url: any): {
+    paypageId: any;
+    txnId: any;
+    code: any;
+} | null;
+declare function eprotectRefusalCode(bodyText: any): any;
+export { EPROTECT_HOSTS, EPROTECT_KEYS, EPROTECT_MERCHANT_PINS, EPROTECT_PATH, EPROTECT_REFUSAL_CODES, EPROTECT_SECONDARY_HOST, EPROTECT_TEST_PANS, eprotectCardRefusal, eprotectDeviceRequest, eprotectEncrypt, eprotectEnvironment, eprotectGiveUp, eprotectJsonp, eprotectMerchantPin, eprotectMerchantRefusal, eprotectOutcome, eprotectPreparationUrl, eprotectRefusalCode, eprotectRequestFacts, eprotectSecondaryAttempt, isEprotectDeviceRequest, isEprotectRequest, isEprotectTokenRequest, isPreparedEprotectRequest, sanitizeEprotectRegistration };