perimeterx-js-core 0.7.1 → 0.8.0

package/lib/products/credential_intelligence/endpoint/login_successful/HeaderLoginSuccessfulParser.js

@@ -1,23 +1,14 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 export class HeaderLoginSuccessfulParser {
+    headerName;
+    headerValue;
     constructor(headerName, headerValue) {
         this.headerName = headerName;
         this.headerValue = headerValue || null;
     }
-    isLoginSuccessful(response) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.headerValue) {
-                return response.headers.get(this.headerName) === this.headerValue;
-            }
-            return response.headers.has(this.headerName);
-        });
+    async isLoginSuccessful(response) {
+        if (this.headerValue) {
+            return response.headers.get(this.headerName) === this.headerValue;
+        }
+        return response.headers.has(this.headerName);
     }
 }

package/lib/products/credential_intelligence/endpoint/login_successful/LoginSuccessfulParserFactory.js

@@ -6,19 +6,20 @@ import { StatusLoginSuccessfulParser } from './StatusLoginSuccessfulParser';
 import { EnforcerError } from '../../../../utils';
 export class LoginSuccessfulParserFactory {
     static create(config, endpointConfig) {
-        var _a;
         const { ciDefaultLoginSuccessfulReportingMethod, ciDefaultLoginSuccessfulBodyRegex, ciDefaultLoginSuccessfulStatus, ciDefaultLoginSuccessfulCustomCallback, ciDefaultLoginSuccessfulHeaderName, ciDefaultLoginSuccessfulHeaderValue, } = config;
         const { login_successful_reporting_method, login_successful_callback, login_successful_statuses, login_successful_body_regex, login_successful_header_name, login_successful_header_value, } = endpointConfig;
-        const reportingMethod = (_a = login_successful_reporting_method !== null && login_successful_reporting_method !== void 0 ? login_successful_reporting_method : ciDefaultLoginSuccessfulReportingMethod) !== null && _a !== void 0 ? _a : LoginSuccessfulReportingMethod.STATUS;
+        const reportingMethod = login_successful_reporting_method ??
+            ciDefaultLoginSuccessfulReportingMethod ??
+            LoginSuccessfulReportingMethod.STATUS;
         switch (reportingMethod) {
             case LoginSuccessfulReportingMethod.BODY:
-                return new BodyLoginSuccessfulParser(login_successful_body_regex !== null && login_successful_body_regex !== void 0 ? login_successful_body_regex : ciDefaultLoginSuccessfulBodyRegex);
+                return new BodyLoginSuccessfulParser(login_successful_body_regex ?? ciDefaultLoginSuccessfulBodyRegex);
             case LoginSuccessfulReportingMethod.CUSTOM:
-                return new CustomLoginSuccessfulParser(login_successful_callback !== null && login_successful_callback !== void 0 ? login_successful_callback : ciDefaultLoginSuccessfulCustomCallback);
+                return new CustomLoginSuccessfulParser(login_successful_callback ?? ciDefaultLoginSuccessfulCustomCallback);
             case LoginSuccessfulReportingMethod.HEADER:
-                return new HeaderLoginSuccessfulParser(login_successful_header_name !== null && login_successful_header_name !== void 0 ? login_successful_header_name : ciDefaultLoginSuccessfulHeaderName, login_successful_header_value !== null && login_successful_header_value !== void 0 ? login_successful_header_value : ciDefaultLoginSuccessfulHeaderValue);
+                return new HeaderLoginSuccessfulParser(login_successful_header_name ?? ciDefaultLoginSuccessfulHeaderName, login_successful_header_value ?? ciDefaultLoginSuccessfulHeaderValue);
             case LoginSuccessfulReportingMethod.STATUS:
-                return new StatusLoginSuccessfulParser(login_successful_statuses !== null && login_successful_statuses !== void 0 ? login_successful_statuses : ciDefaultLoginSuccessfulStatus);
+                return new StatusLoginSuccessfulParser(login_successful_statuses ?? ciDefaultLoginSuccessfulStatus);
             default:
                 throw new EnforcerError('unknown login successful reporting method defined');
         }

package/lib/products/credential_intelligence/endpoint/login_successful/StatusLoginSuccessfulParser.js

@@ -1,19 +1,9 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 export class StatusLoginSuccessfulParser {
+    statuses;
     constructor(statuses) {
         this.statuses = statuses;
     }
-    isLoginSuccessful(response) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.statuses.includes(response.status);
-        });
+    async isLoginSuccessful(response) {
+        return this.statuses.includes(response.status);
     }
 }

package/lib/products/credential_intelligence/endpoint/matcher/ExactPathEndpointMatcher.js

@@ -1,4 +1,6 @@
 export class ExactPathEndpointMatcher {
+    pathname;
+    method;
     constructor(pathname, method) {
         this.pathname = pathname;
         this.method = method;

package/lib/products/credential_intelligence/endpoint/matcher/RegexPathEndpointMatcher.js

@@ -1,4 +1,6 @@
 export class RegexPathEndpointMatcher {
+    pathnameRegex;
+    method;
     constructor(pathname, method) {
         this.pathnameRegex = pathname;
         this.method = method;

package/lib/pxde/DefaultDataEnrichment.js

@@ -1,74 +1,60 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { Algorithm, PXDE_COOKIE_NAME } from '../utils';
 import { PXDE_COOKIE_DELIMITER, PXDE_COOKIE_PARTS_COUNT, PXDE_HMAC_INDEX, PXDE_PAYLOAD_INDEX } from './constants';
 export class DefaultDataEnrichment {
+    config;
+    base64Utils;
+    hmacUtils;
     constructor(config, base64Utils, hmacUtils) {
         this.config = config;
         this.base64Utils = base64Utils;
         this.hmacUtils = hmacUtils;
     }
-    handlePxde(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const pxdeCookie = context.requestData.cookies[PXDE_COOKIE_NAME];
-                if (pxdeCookie) {
-                    return yield this.parsePxde(pxdeCookie);
-                }
-            }
-            catch (e) {
-                this.config.logger.debug(`unable to parse pxde cookie - ${e}`);
-            }
-            return null;
-        });
+    async handlePxde(context) {
+        try {
+            const pxdeCookie = context.requestData.cookies[PXDE_COOKIE_NAME];
+            if (pxdeCookie) {
+                return await this.parsePxde(pxdeCookie);
+            }
+        }
+        catch (e) {
+            this.config.logger.debug(`unable to parse pxde cookie - ${e}`);
+        }
+        return null;
     }
-    parsePxde(pxdeCookie) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const pxdeParts = pxdeCookie.split(PXDE_COOKIE_DELIMITER);
-            if (pxdeParts.length !== PXDE_COOKIE_PARTS_COUNT) {
-                this.config.logger.debug(`malformed pxde cookie: ${pxdeCookie}`);
-                return null;
-            }
-            const hmac = pxdeParts[PXDE_HMAC_INDEX];
-            const encodedPayload = pxdeParts[PXDE_PAYLOAD_INDEX];
-            if (!hmac || !encodedPayload) {
-                this.config.logger.debug(`malformed pxde cookie: hmac: ${hmac}, payload: ${encodedPayload}`);
-                return null;
-            }
-            return {
-                pxde: yield this.parsePxdePayload(encodedPayload),
-                pxdeVerified: yield this.verifyPxdeHmac(hmac, encodedPayload),
-            };
-        });
+    async parsePxde(pxdeCookie) {
+        const pxdeParts = pxdeCookie.split(PXDE_COOKIE_DELIMITER);
+        if (pxdeParts.length !== PXDE_COOKIE_PARTS_COUNT) {
+            this.config.logger.debug(`malformed pxde cookie: ${pxdeCookie}`);
+            return null;
+        }
+        const hmac = pxdeParts[PXDE_HMAC_INDEX];
+        const encodedPayload = pxdeParts[PXDE_PAYLOAD_INDEX];
+        if (!hmac || !encodedPayload) {
+            this.config.logger.debug(`malformed pxde cookie: hmac: ${hmac}, payload: ${encodedPayload}`);
+            return null;
+        }
+        return {
+            pxde: await this.parsePxdePayload(encodedPayload),
+            pxdeVerified: await this.verifyPxdeHmac(hmac, encodedPayload),
+        };
     }
-    verifyPxdeHmac(givenHmac, encodedPayload) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return givenHmac === this.hmacUtils.createHmac(Algorithm.SHA256, encodedPayload, this.config.cookieSecret);
-            }
-            catch (e) {
-                this.config.logger.debug(`failed verifying pxde hmac: ${e}`);
-                return false;
-            }
-        });
+    async verifyPxdeHmac(givenHmac, encodedPayload) {
+        try {
+            return givenHmac === this.hmacUtils.createHmac(Algorithm.SHA256, encodedPayload, this.config.cookieSecret);
+        }
+        catch (e) {
+            this.config.logger.debug(`failed verifying pxde hmac: ${e}`);
+            return false;
+        }
     }
-    parsePxdePayload(encodedPayload) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const decodedPayload = this.base64Utils.base64Decode(encodedPayload);
-                return JSON.parse(decodedPayload);
-            }
-            catch (e) {
-                this.config.logger.debug(`failed parsing pxde payload: ${e}`);
-                return null;
-            }
-        });
+    async parsePxdePayload(encodedPayload) {
+        try {
+            const decodedPayload = this.base64Utils.base64Decode(encodedPayload);
+            return JSON.parse(decodedPayload);
+        }
+        catch (e) {
+            this.config.logger.debug(`failed parsing pxde payload: ${e}`);
+            return null;
+        }
     }
 }

package/lib/pxhd/PXHDUtils.js

@@ -5,14 +5,14 @@ export var PXHDUtils;
     PXHDUtils.PXHD_SAMESITE_VALUE = 'Lax';
     PXHDUtils.PXHD_PATH_VALUE = '/';
     PXHDUtils.addPxhdToOutgoingResponse = (context, response) => {
-        if (!(context === null || context === void 0 ? void 0 : context.pxhd)) {
+        if (!context?.pxhd) {
             return;
         }
         const setPxhdCookie = PXHDUtils.getPxhdCookieValue(context.pxhd);
         response.headers.append(SET_COOKIE_HEADER_NAME, setPxhdCookie);
     };
     PXHDUtils.addPxhdToMinimalResponse = (context, response) => {
-        if (context === null || context === void 0 ? void 0 : context.pxhd) {
+        if (context?.pxhd) {
             const setPxhdCookie = PXHDUtils.getPxhdCookieValue(context.pxhd);
             return MinimalResponseUtils.appendHeader(response, SET_COOKIE_HEADER_NAME, setPxhdCookie);
         }

package/lib/risk_api/client/PostRiskApiClientBase.d.ts

@@ -1,6 +1,7 @@
 import { ReadonlyContext, RiskApiData } from '../../context';
 import { IConfiguration } from '../../config';
-import { IHttpClient, IIncomingResponse } from '../../http';
+import { IHttpClient, IIncomingResponse, ReadonlyHeaders } from '../../http';
+import { HeaderEntry } from '../../activities';
 import { RiskActivity } from '../model';
 import { IRiskResponse } from '../risk_response';
 import { IRiskApiClient } from './IRiskApiClient';
@@ -29,16 +30,10 @@ export declare abstract class PostRiskApiClientBase<Req, Res> implements IRiskAp
      * @protected
      */
     protected finalizeRiskActivity(riskActivity: RiskActivity): RiskActivity;
-    private addOptionalRiskFields;
-    private addOptionalRiskFieldsToRoot;
-    private addOptionalRiskFieldsToAdditional;
-    private addProductDataToAdditional;
-    private addCustomParamsToAdditional;
-    private addTokenDataToAdditional;
-    private formatRiskHeadersField;
+    protected formatRiskHeadersField(headers: ReadonlyHeaders): HeaderEntry[];
     protected sendRiskActivity(riskActivity: RiskActivity, riskApiData: RiskApiData): Promise<IIncomingResponse>;
-    private getRiskUrl;
-    private getRiskHeaders;
-    private handleS2STimeout;
-    private handleS2SError;
+    protected getRiskUrl(): string;
+    protected getRiskHeaders(): ReadonlyHeaders;
+    protected handleS2STimeout(riskApiData: RiskApiData): RiskApiData;
+    protected handleS2SError(riskApiData: RiskApiData, response: IIncomingResponse, error?: Error): Promise<RiskApiData>;
 }

package/lib/risk_api/client/PostRiskApiClientBase.js

@@ -1,19 +1,11 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { ProductName } from '../../products';
 import { AUTHORIZATION_HEADER_NAME, CONTENT_TYPE_HEADER_NAME, ContentType, HttpMethod, OutgoingRequestImpl, } from '../../http';
-import { EnforcerErrorName, getAuthorizationHeader, ModuleMode, removeSensitiveHeaders, transferExistingProperties, } from '../../utils';
+import { EnforcerErrorName, getAuthorizationHeader, removeSensitiveHeaders, } from '../../utils';
+import { createCommonActivityDetails, toHeaderEntryArray } from '../../activities';
 import { RISK_API_ENDPOINT } from '../constants';
 import { RiskApiCallResult, RiskStatus, S2SErrorReason } from '../model';
-import { TokenParseResult } from '../../risk_token';
 export class PostRiskApiClientBase {
+    config;
+    httpClient;
     constructor(config, httpClient) {
         this.config = config;
         this.httpClient = httpClient;
@@ -23,32 +15,30 @@ export class PostRiskApiClientBase {
      * @param context
      * @returns Promise<RiskApiData>
      */
-    executeRiskApi(context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let response, riskResponse;
-            const riskApiData = { riskApiCallResult: RiskApiCallResult.NONE };
-            try {
-                const riskActivity = this.createRiskActivity(context);
-                response = yield this.sendRiskActivity(riskActivity, riskApiData);
-                if ((response === null || response === void 0 ? void 0 : response.status) !== 200) {
-                    return yield this.handleS2SError(riskApiData, response);
-                }
-                riskResponse = this.createRiskResponse(response);
-                riskApiData.riskResponse = riskResponse;
-                if (!(yield riskResponse.validate())) {
-                    return yield this.handleS2SError(riskApiData, response);
-                }
-                this.config.logger.debug(`received risk response, score: ${riskResponse.score}, rtt: ${riskApiData.riskRtt}`);
-                return riskApiData;
+    async executeRiskApi(context) {
+        let response, riskResponse;
+        const riskApiData = { riskApiCallResult: RiskApiCallResult.NONE };
+        try {
+            const riskActivity = this.createRiskActivity(context);
+            response = await this.sendRiskActivity(riskActivity, riskApiData);
+            if (response?.status !== 200) {
+                return await this.handleS2SError(riskApiData, response);
             }
-            catch (err) {
-                if (err.name === EnforcerErrorName.ENFORCER_TIMEOUT_ERROR) {
-                    return this.handleS2STimeout(riskApiData);
-                }
-                this.config.logger.error(`caught error in risk api: ${err} - ${JSON.stringify(context.requestData.url)}`);
-                return yield this.handleS2SError(riskApiData, response, err);
+            riskResponse = this.createRiskResponse(response);
+            riskApiData.riskResponse = riskResponse;
+            if (!(await riskResponse.validate())) {
+                return await this.handleS2SError(riskApiData, response);
             }
-        });
+            this.config.logger.debug(`received risk response, score: ${riskResponse.score}, rtt: ${riskApiData.riskRtt}`);
+            return riskApiData;
+        }
+        catch (err) {
+            if (err.name === EnforcerErrorName.ENFORCER_TIMEOUT_ERROR) {
+                return this.handleS2STimeout(riskApiData);
+            }
+            this.config.logger.error(`caught error in risk api: ${err} - ${JSON.stringify(context.requestData.url)}`);
+            return await this.handleS2SError(riskApiData, response, err);
+        }
     }
     /**
      * Creates the RiskActivity payload
@@ -57,26 +47,20 @@ export class PostRiskApiClientBase {
      * @protected
      */
     createRiskActivity(context) {
-        var _a, _b, _c;
         const riskActivity = {
+            vid: context.vid,
+            client_uuid: context.uuid,
+            pxhd: context.pxhd?.value,
             request: {
-                ip: context.requestData.ip,
+                socket_ip: context.requestData.ip,
                 headers: this.formatRiskHeadersField(context.requestData.headers),
                 url: context.requestData.rawUrl,
             },
             additional: {
-                s2s_call_reason: ((_a = context.reasons) === null || _a === void 0 ? void 0 : _a[ProductName.BOT_DEFENDER]) ||
-                    ((_b = context.reasons) === null || _b === void 0 ? void 0 : _b[ProductName.CREDENTIAL_INTELLIGENCE]),
-                module_version: this.config.moduleVersion,
-                http_method: context.requestData.method,
-                http_version: context.requestData.httpVersion,
-                risk_mode: ((_c = context.productData.bd) === null || _c === void 0 ? void 0 : _c.isMonitoredRequest) ? ModuleMode.MONITOR : ModuleMode.ACTIVE_BLOCKING,
-                cookie_origin: context.tokenOrigin,
-                request_cookie_names: context.requestData.requestCookieNames.concat(),
-                request_id: context.requestId,
+                ...createCommonActivityDetails(this.config, context),
+                s2s_call_reason: context.riskApiData.s2sCallReason,
             },
         };
-        this.addOptionalRiskFields(riskActivity, context);
         return this.finalizeRiskActivity(riskActivity);
     }
     /**
@@ -88,105 +72,23 @@ export class PostRiskApiClientBase {
     finalizeRiskActivity(riskActivity) {
         return riskActivity;
     }
-    addOptionalRiskFields(riskActivity, context) {
-        this.addOptionalRiskFieldsToRoot(riskActivity, context);
-        this.addOptionalRiskFieldsToAdditional(riskActivity, context);
-        this.addProductDataToAdditional(riskActivity, context.productData);
-        this.addTokenDataToAdditional(riskActivity, context.tokenData);
-        this.addCustomParamsToAdditional(riskActivity, context);
-    }
-    addOptionalRiskFieldsToRoot(riskActivity, context) {
-        var _a;
-        transferExistingProperties(context, riskActivity, {
-            vid: 'vid',
-            uuid: 'uuid',
-        });
-        if ((_a = context.pxhd) === null || _a === void 0 ? void 0 : _a.value) {
-            riskActivity.pxhd = context.pxhd.value;
-        }
-    }
-    addOptionalRiskFieldsToAdditional(riskActivity, context) {
-        transferExistingProperties(context, riskActivity.additional, {
-            vidSource: 'enforcer_vid_source',
-            graphqlData: 'graphql_operations',
-        });
-        transferExistingProperties(context.serverData, riskActivity.additional, {
-            region: 'server_info_region',
-            datacenter: 'server_info_datacenter',
-        });
-        transferExistingProperties(context.tlsData, riskActivity.additional, {
-            tlsProtocol: 'tls_protocol',
-            tlsServer: 'tls_server',
-            tlsCipher: 'tls_cipher',
-            tlsCiphersSha: 'tls_ciphers_sha',
-            tlsExtensionSha: 'tls_extension_sha',
-            tlsPreferredCiphers: 'tls_preferred_ciphers',
-            tlsJa3Fingerprint: 'tls_ja3_fingerprint',
-        });
-    }
-    addProductDataToAdditional(riskActivity, productData) {
-        transferExistingProperties(productData.ad, riskActivity.additional, {
-            appUserId: 'app_user_id',
-            additionalFields: 'jwt_additional_fields',
-            crossTabSession: 'cross_tab_session',
-        });
-        transferExistingProperties(productData.ci, riskActivity.additional, {
-            hashedUsername: 'user',
-            hashedPassword: 'pass',
-            ciVersion: 'ci_version',
-            ssoStep: 'sso_step',
-        });
-    }
-    addCustomParamsToAdditional(riskActivity, context) {
-        if (context.customParameters) {
-            Object.assign(riskActivity.additional, context.customParameters);
-        }
-    }
-    addTokenDataToAdditional(riskActivity, { token, mobileData }) {
-        if (token) {
-            if (token.isValid()) {
-                riskActivity.additional.px_cookie = token.getPayloadString();
-                riskActivity.additional.px_cookie_hmac = token.hmac;
-            }
-            else {
-                riskActivity.additional.px_orig_cookie = token.getTokenString();
-            }
-        }
-        if (mobileData) {
-            transferExistingProperties(mobileData, riskActivity.additional, {
-                originalToken: 'original_token',
-                decodedOriginalToken: 'px_decoded_original_token',
-            });
-            if (mobileData.originalTokenParseResult === TokenParseResult.DECRYPTION_FAILED) {
-                riskActivity.additional.original_token_error = 'cookie_decryption_failed';
-            }
-            else if (mobileData.originalTokenParseResult === TokenParseResult.VALIDATION_FAILED) {
-                riskActivity.additional.original_token_error = 'cookie_validation_failed';
-            }
-        }
-    }
     formatRiskHeadersField(headers) {
         const headersWithoutSensitive = removeSensitiveHeaders(headers, this.config.sensitiveHeaders);
-        return Object.entries(headersWithoutSensitive).flatMap(([key, values]) => values.map((value) => ({
-            name: key,
-            value: value,
-        })));
-    }
-    sendRiskActivity(riskActivity, riskApiData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const url = this.getRiskUrl();
-            const headers = this.getRiskHeaders();
-            const body = JSON.stringify(riskActivity);
-            const method = HttpMethod.POST;
-            const riskRequest = new OutgoingRequestImpl({ url, method, headers, body });
-            this.config.logger.debug(`sending risk api to ${url}`);
-            const startTime = Date.now();
-            const response = yield this.httpClient.send(riskRequest, { timeoutMs: this.config.s2sTimeout });
-            const endTime = Date.now();
-            riskApiData.riskApiCallResult = RiskApiCallResult.SUCCESSFUL;
-            riskApiData.riskRtt = endTime - startTime;
-            return response;
-        });
+        return toHeaderEntryArray(headersWithoutSensitive);
+    }
+    async sendRiskActivity(riskActivity, riskApiData) {
+        const url = this.getRiskUrl();
+        const headers = this.getRiskHeaders();
+        const body = JSON.stringify(riskActivity);
+        const method = HttpMethod.POST;
+        const riskRequest = new OutgoingRequestImpl({ url, method, headers, body });
+        this.config.logger.debug(`sending risk api to ${url}`);
+        const startTime = Date.now();
+        const response = await this.httpClient.send(riskRequest, { timeoutMs: this.config.s2sTimeout });
+        const endTime = Date.now();
+        riskApiData.riskApiCallResult = RiskApiCallResult.SUCCESSFUL;
+        riskApiData.riskRtt = endTime - startTime;
+        return response;
     }
     getRiskUrl() {
         return `${this.config.backendScoreApiUrl}${RISK_API_ENDPOINT}`;
@@ -201,35 +103,32 @@ export class PostRiskApiClientBase {
         riskApiData.riskApiCallResult = RiskApiCallResult.TIMEOUT;
         return riskApiData;
     }
-    handleS2SError(riskApiData, response, error) {
-        var _a, _b, _c;
-        return __awaiter(this, void 0, void 0, function* () {
-            riskApiData.riskApiCallResult = RiskApiCallResult.ERROR;
-            riskApiData.errorReason = S2SErrorReason.UNKNOWN_ERROR;
-            if (response || riskApiData.riskResponse) {
-                riskApiData.errorHttpStatus = response.status;
-                riskApiData.errorMessage = ((_a = riskApiData.riskResponse) === null || _a === void 0 ? void 0 : _a.message) || `response body: ${yield response.text()}`;
-                if (response.status === 200) {
-                    if (((_b = riskApiData.riskResponse) === null || _b === void 0 ? void 0 : _b.status) === RiskStatus.FAILURE) {
-                        riskApiData.errorReason = S2SErrorReason.REQUEST_FAILED_ON_SERVER;
-                    }
-                    else if (!(yield ((_c = riskApiData.riskResponse) === null || _c === void 0 ? void 0 : _c.validate()))) {
-                        riskApiData.errorReason = S2SErrorReason.INVALID_RESPONSE;
-                    }
-                }
-                else if (response.status >= 400 && response.status < 500) {
-                    riskApiData.errorReason = S2SErrorReason.BAD_REQUEST;
+    async handleS2SError(riskApiData, response, error) {
+        riskApiData.riskApiCallResult = RiskApiCallResult.ERROR;
+        riskApiData.errorReason = S2SErrorReason.UNKNOWN_ERROR;
+        if (response || riskApiData.riskResponse) {
+            riskApiData.errorHttpStatus = response.status;
+            riskApiData.errorMessage = riskApiData.riskResponse?.message || `response body: ${await response.text()}`;
+            if (response.status === 200) {
+                if (riskApiData.riskResponse?.status === RiskStatus.FAILURE) {
+                    riskApiData.errorReason = S2SErrorReason.REQUEST_FAILED_ON_SERVER;
                 }
-                else if (response.status >= 500 && response.status < 600) {
-                    riskApiData.errorReason = S2SErrorReason.SERVER_ERROR;
+                else if (!(await riskApiData.riskResponse?.validate())) {
+                    riskApiData.errorReason = S2SErrorReason.INVALID_RESPONSE;
                 }
             }
-            if (error) {
-                const errorMessage = `${error}`;
-                const existingMessage = riskApiData.errorMessage;
-                riskApiData.errorMessage = existingMessage ? `${existingMessage}, ${errorMessage}` : errorMessage;
+            else if (response.status >= 400 && response.status < 500) {
+                riskApiData.errorReason = S2SErrorReason.BAD_REQUEST;
             }
-            return riskApiData;
-        });
+            else if (response.status >= 500 && response.status < 600) {
+                riskApiData.errorReason = S2SErrorReason.SERVER_ERROR;
+            }
+        }
+        if (error) {
+            const errorMessage = `${error}`;
+            const existingMessage = riskApiData.errorMessage;
+            riskApiData.errorMessage = existingMessage ? `${existingMessage}, ${errorMessage}` : errorMessage;
+        }
+        return riskApiData;
     }
 }

package/lib/risk_api/model/RiskActivity.d.ts

@@ -1,56 +1,16 @@
-import { ModuleMode, VidSource } from '../../utils';
-import { TokenOrigin } from '../../risk_token';
-import { CustomParameters } from '../../custom_parameters';
-import { GraphQLData } from '../../graphql/';
-import { CredentialIntelligenceVersion, SsoStep } from '../../products';
-export type HeaderEntry = {
-    name: string;
-    value: string;
-};
+import { HeaderEntry, CommonActivityDetails } from '../../activities';
 export type RiskRequestData = {
-    ip: string;
+    socket_ip: string;
     url: string;
     headers: HeaderEntry[];
 };
 export type RiskAdditionalData = {
-    request_id: string;
-    module_version: string;
     s2s_call_reason: string;
-    risk_mode: ModuleMode;
-    http_method: string;
-    http_version?: string;
-    px_orig_cookie?: string;
-    px_cookie?: string;
-    px_cookie_hmac?: string;
-    tls_protocol?: string;
-    tls_server?: string;
-    tls_cipher?: string;
-    tls_ciphers_sha?: string;
-    tls_extension_sha?: string;
-    tls_preferred_ciphers?: string;
-    tls_ja3_fingerprint?: string;
-    enforcer_vid_source?: VidSource;
-    original_uuid?: string;
-    original_token_error?: string;
-    original_token?: string;
-    px_decoded_original_token?: string;
-    cookie_origin?: TokenOrigin;
-    request_cookie_names?: string[];
-    server_info_region?: string;
-    server_info_datacenter?: string;
-    cross_tab_session?: string;
-    app_user_id?: string;
-    jwt_additional_fields?: Record<string, any>;
-    graphql_operations?: GraphQLData[];
-    user?: string;
-    pass?: string;
-    ci_version?: CredentialIntelligenceVersion;
-    sso_step?: SsoStep;
-} & CustomParameters;
+};
 export type RiskActivity = {
     vid?: string;
-    uuid?: string;
+    client_uuid?: string;
     pxhd?: string;
     request: RiskRequestData;
-    additional: RiskAdditionalData;
+    additional: RiskAdditionalData & CommonActivityDetails;
 };

package/lib/risk_api/risk_response/IRiskResponse.d.ts

@@ -11,5 +11,6 @@ export interface IRiskResponse {
     readonly pxhdDomain?: string;
     readonly message?: string;
     readonly dataEnrichment?: PXDE;
+    readonly additionalRiskInfo?: string;
     validate(): AsyncOrSync<boolean>;
 }

package/lib/risk_api/risk_response/RiskResponseBase.d.ts

@@ -19,4 +19,5 @@ export declare abstract class RiskResponseBase<TokenV extends TokenVersion> impl
     get uuid(): string;
     get dataEnrichment(): PXDE;
     get pxhdDomain(): string;
+    get additionalRiskInfo(): string;
 }