web3-banking-system-sdk 1.0.0

package/dist/helper/cipherHelper.js

@@ -0,0 +1,187 @@
+import { createCipheriv, createDecipheriv } from "crypto";
+class CipherHelper {
+    // #region "Properties"
+    errorHandler;
+    // #endregion
+    // #region "Constructor"
+    constructor(errorHandler) {
+        this.errorHandler = errorHandler;
+    }
+    // #endregion
+    // #region "Encrypt"
+    encrypt = (plainText, key, iv, urlSafe = false) => {
+        try {
+            const encoding = urlSafe ? "base64url" : "base64";
+            const keyBuffer = Buffer.from(key, "utf8");
+            const ivBuffer = Buffer.from(iv, "utf8");
+            const cipher = createCipheriv("aes-256-cbc", keyBuffer, ivBuffer);
+            let encrypted = cipher.update(plainText, "utf8", encoding);
+            encrypted += cipher.final(encoding);
+            return encrypted;
+        }
+        catch (error) {
+            this.errorHandler(error);
+            return "";
+        }
+    };
+    encryptAsJson = (plainText, cookieKey, key, iv) => {
+        try {
+            const json = JSON.stringify({ [cookieKey]: plainText });
+            const encrypted = this.encrypt(json, key, iv);
+            return encrypted;
+        }
+        catch (error) {
+            this.errorHandler(error);
+            return "";
+        }
+    };
+    encryptByProgramID = (plainText, programId) => {
+        try {
+            const { key, iv } = this.generateByProgramID(programId);
+            return this.encrypt(plainText, key, iv, true);
+        }
+        catch (error) {
+            this.errorHandler(error);
+            return "";
+        }
+    };
+    // #endregion
+    // #region "Decrypt"
+    decrypt = (cipherText, key, iv, urlSafe = false) => {
+        try {
+            const encoding = urlSafe ? "base64url" : "base64";
+            const keyBuffer = Buffer.from(key, "utf8");
+            const ivBuffer = Buffer.from(iv, "utf8");
+            const decipher = createDecipheriv("aes-256-cbc", keyBuffer, ivBuffer);
+            let decrypted = decipher.update(cipherText, encoding, "utf8");
+            decrypted += decipher.final("utf8");
+            return decrypted;
+        }
+        catch (error) {
+            this.errorHandler(error);
+            return "";
+        }
+    };
+    decryptAsJson = (cipherText, key, iv) => {
+        try {
+            const decryptedJSON = this.decrypt(cipherText, key, iv);
+            if (decryptedJSON == "{}") {
+                return { [key]: "" };
+            }
+            const decrypted = JSON.parse(decryptedJSON);
+            if (!decrypted) {
+                return { [key]: "" };
+            }
+            return decrypted;
+        }
+        catch (error) {
+            this.errorHandler(error);
+            return { [key]: "" };
+        }
+    };
+    decryptByProgramID = (cipherText, programId) => {
+        try {
+            const { key, iv } = this.generateByProgramID(programId);
+            return this.decrypt(cipherText, key, iv, true);
+        }
+        catch (error) {
+            this.errorHandler(error);
+            return "";
+        }
+    };
+    // #endregion
+    // #region "Generate"
+    generate = (code) => {
+        try {
+            if (!code)
+                throw new Error("code is not defined");
+            const KEY = this.PaddingLeft(code.toString(), 32, "0");
+            const IV = this.PaddingLeft(code.toString(), 16, "0");
+            return { key: KEY, iv: IV };
+        }
+        catch (error) {
+            this.errorHandler(error);
+            return { key: "", iv: "" };
+        }
+    };
+    generateByUSRAndIID = (USR, IID) => {
+        try {
+            if (!USR || !USR.device_id || !USR.user_id) {
+                throw new Error("USR is not defined");
+            }
+            if (!IID) {
+                throw new Error("IID is not defined");
+            }
+            const DID_KEY = this.PaddingLeft(USR.device_id.toString(), 10, "0");
+            const UID_KEY = this.PaddingLeft(USR.user_id.toString(), 10, "0");
+            const IID_KEY = IID.slice(0, 10);
+            const KEY = `${DID_KEY}.${UID_KEY}.${IID_KEY}`.toString();
+            const DID_IV = this.PaddingLeft(USR.device_id.toString(), 8, "0");
+            const UID_IV = this.PaddingLeft(USR.user_id.toString(), 8, "0");
+            const IV = `${DID_IV}${UID_IV}`;
+            return { key: KEY, iv: IV };
+        }
+        catch (error) {
+            this.errorHandler(error);
+            return { key: "", iv: "" };
+        }
+    };
+    generateByProgramID = (programId) => {
+        try {
+            if (!programId) {
+                throw new Error("Program ID is not defined");
+            }
+            const PID_KEY = this.PaddingLeft(programId, 10, "0");
+            const F_KEY = this.PaddingLeft("0".toString(), 10, "0");
+            const FingerPrint_KEY = this.PaddingLeft("", 10, "0");
+            const KEY = `${PID_KEY}.${F_KEY}.${FingerPrint_KEY}`;
+            const PID_IV = this.PaddingLeft(programId, 8, "0");
+            const F_IV = this.PaddingLeft("0".toString(), 8, "0");
+            const IV = `${PID_IV}${F_IV}`;
+            return { key: KEY, iv: IV };
+        }
+        catch (error) {
+            this.errorHandler(error);
+            return { key: "", iv: "" };
+        }
+    };
+    generateByUserID = (user_id) => {
+        try {
+            const UID_KEY = this.PaddingLeft(user_id.toString(), 32, "0");
+            const UID_IV = this.PaddingLeft(user_id.toString(), 16, "0");
+            return { key: UID_KEY, iv: UID_IV };
+        }
+        catch (error) {
+            this.errorHandler(error);
+            return { key: "", iv: "" };
+        }
+    };
+    generateByInstallationID = (IID) => {
+        try {
+            if (!IID) {
+                throw new Error("Installation ID is not defined");
+            }
+            const IID_KEY = IID.slice(0, 32);
+            const IID_IV = IID.slice(0, 16);
+            return { key: IID_KEY, iv: IID_IV };
+        }
+        catch (error) {
+            this.errorHandler(error);
+            return { key: "", iv: "" };
+        }
+    };
+    // #endregion
+    // #region "Utils"
+    PaddingLeft = (value, length, paddingChar) => {
+        try {
+            if (value.length >= length)
+                return value;
+            return paddingChar.repeat(length - value.length) + value;
+        }
+        catch (error) {
+            this.errorHandler(error);
+            return "";
+        }
+    };
+}
+export { CipherHelper };

package/dist/helper/clientHelper.d.ts

@@ -0,0 +1,13 @@
+declare class ClientHelper {
+    private clientBrowserData;
+    constructor();
+    getBrowser(): string | undefined;
+    getBrowserVersion(): string | undefined;
+    getOS(): string | undefined;
+    getOSVersion(): string | undefined;
+    getCPU(): string;
+    getUserAgent(): string;
+    getSystemLanguage(): string;
+    isHostOnly(): boolean;
+}
+export { ClientHelper };

package/dist/helper/clientHelper.js

@@ -0,0 +1,34 @@
+import { UAParser } from "ua-parser-js";
+class ClientHelper {
+    clientBrowserData;
+    constructor() {
+        const uaParser = new UAParser();
+        this.clientBrowserData = uaParser.getResult();
+    }
+    getBrowser() {
+        return this.clientBrowserData.browser.name;
+    }
+    getBrowserVersion() {
+        return this.clientBrowserData.browser.version;
+    }
+    getOS() {
+        return this.clientBrowserData.os.name;
+    }
+    getOSVersion() {
+        return this.clientBrowserData.os.version;
+    }
+    getCPU() {
+        return this.clientBrowserData.cpu.architecture;
+    }
+    getUserAgent() {
+        return this.clientBrowserData.ua;
+    }
+    getSystemLanguage() {
+        return window.navigator.language;
+    }
+    isHostOnly() {
+        const host = window.location.hostname;
+        return host === "localhost";
+    }
+}
+export { ClientHelper };

package/dist/helper/dateTimeHelper.d.ts

@@ -0,0 +1,8 @@
+declare class DateTimeHelper {
+    static now(): number;
+    static getClientTimeZone(): string;
+    static getClientTimeZoneName(): string;
+    static getDateUTC(): string;
+    static getClientDate(): string;
+}
+export { DateTimeHelper };

package/dist/helper/dateTimeHelper.js

@@ -0,0 +1,23 @@
+import dayjs from "dayjs";
+import utc from "dayjs/plugin/utc";
+import timezone from "dayjs/plugin/timezone";
+dayjs.extend(utc);
+dayjs.extend(timezone);
+class DateTimeHelper {
+    static now() {
+        return new Date().getTime();
+    }
+    static getClientTimeZone() {
+        return `UTC ${dayjs.tz(new Date()).format("Z")}`;
+    }
+    static getClientTimeZoneName() {
+        return dayjs.tz(new Date()).format("Z");
+    }
+    static getDateUTC() {
+        return dayjs.utc(new Date()).format("YYYY-MM-DD HH:mm:ss.SSS");
+    }
+    static getClientDate() {
+        return dayjs.tz(new Date()).format("YYYY-MM-DD HH:mm:ss.SSS");
+    }
+}
+export { DateTimeHelper };

package/dist/helper/deviceHelper.d.ts

@@ -0,0 +1,12 @@
+import type { Device, DeviceTableSubscriptionData, FilledDeviceTableData } from "../types";
+import { CookiesHelper } from "./";
+declare class DeviceHelper {
+    static getDeviceDetails: (asJson?: boolean) => string | Device;
+    static sortDevices: (devices: Device[], installationId: string) => Device[];
+    static getDeviceExtendedInfo: () => void;
+    static fillDeviceDataByDeviceTable(rows: DeviceTableSubscriptionData[], cookiesHelper: CookiesHelper): Promise<FilledDeviceTableData>;
+    static mapDeviceTableRows: (rows: DeviceTableSubscriptionData[], installationId: string | null) => FilledDeviceTableData;
+    private static fillDeviceDataByDeviceRow;
+    private static parseExtendedInfo;
+}
+export { DeviceHelper };

package/dist/helper/deviceHelper.js

@@ -0,0 +1,114 @@
+import { DeviceType } from "../constant";
+import { ClientHelper } from "./clientHelper";
+import { DateTimeHelper } from "./dateTimeHelper";
+class DeviceHelper {
+    static getDeviceDetails = (asJson = false) => {
+        const clientHelper = new ClientHelper();
+        const device = {
+            type: DeviceType.Browser,
+            brand: `${clientHelper.getBrowser()}-${clientHelper.getBrowserVersion()}`,
+            os: clientHelper.getOS(),
+            extended_info: {
+                sim_info: null,
+                culture_info: null,
+                user_agent: clientHelper.getUserAgent(),
+                fingerprint: "",
+                cpu: clientHelper.getCPU(),
+                system_language: clientHelper.getSystemLanguage(),
+            },
+        };
+        const fullDevice = {
+            ...device,
+            application_version: "",
+            serial_number: "",
+            source_ip_address: "",
+            geo_coordinates: "",
+            installation_id: "",
+            client_time_zone: DateTimeHelper.getClientTimeZone(),
+            server_date: "",
+            date_utc: DateTimeHelper.getDateUTC(),
+            client_date: DateTimeHelper.getClientDate(),
+            update_date_utc: DateTimeHelper.getDateUTC(),
+            original_source_id: "",
+        };
+        if (asJson)
+            return JSON.stringify(fullDevice);
+        return fullDevice;
+    };
+    static sortDevices = (devices, installationId) => {
+        return [...devices].sort((a, b) => {
+            if (a.installation_id === installationId &&
+                b.installation_id !== installationId)
+                return -1;
+            if (a.installation_id !== installationId &&
+                b.installation_id === installationId)
+                return 1;
+            if (a.is_online && !b.is_online)
+                return -1;
+            if (!a.is_online && b.is_online)
+                return 1;
+            if (a.verification_status > b.verification_status)
+                return -1;
+            if (a.verification_status < b.verification_status)
+                return 1;
+            const aTime = new Date(a.update_date_utc || a.date_utc).getTime();
+            const bTime = new Date(b.update_date_utc || b.date_utc).getTime();
+            return bTime - aTime;
+        });
+    };
+    static getDeviceExtendedInfo = () => { };
+    static async fillDeviceDataByDeviceTable(rows, cookiesHelper) {
+        const IID = await cookiesHelper.getIID();
+        return DeviceHelper.mapDeviceTableRows(rows, IID);
+    }
+    static mapDeviceTableRows = (rows, installationId) => {
+        let currentDevice = null;
+        const devices = rows.map((row) => {
+            const device = DeviceHelper.fillDeviceDataByDeviceRow(row);
+            if (installationId && device.installation_id === installationId) {
+                currentDevice = device;
+            }
+            return device;
+        });
+        return { devices, currentDevice };
+    };
+    static fillDeviceDataByDeviceRow(row) {
+        return {
+            id: row.ID,
+            type: row.Type,
+            brand: row.Brand?.toString() ?? "",
+            os: row.OS ?? "",
+            unique_id: null,
+            installation_id: row.Installation_ID ?? "",
+            extended_info: this.parseExtendedInfo(row.JSON),
+            status: row.Status,
+            verification_status: row.Verification_Status,
+            is_online: row.Is_Online,
+            encryption_key: row.Encryption_Key ?? "",
+            application_version: row.Application_Version ?? "",
+            serial_number: row.Serial_Number ?? "",
+            source_ip_address: row.Source_IP_Address ?? "",
+            geo_coordinates: row.Geo_Coordinates
+                ? JSON.parse(row.Geo_Coordinates)
+                : undefined,
+            original_source_id: row.Source_ID ?? "",
+            server_date: row.Server_DateTime,
+            date_utc: row.DateTime_UTC,
+            client_date: "",
+            update_date_utc: row.Update_DateTime_UTC,
+            client_time_zone: row.Client_Time_Zone ?? "",
+        };
+    }
+    static parseExtendedInfo(json) {
+        const parsed = json ? JSON.parse(json) : {};
+        return {
+            sim_info: null,
+            culture_info: null,
+            user_agent: parsed.user_agent ?? "",
+            fingerprint: "",
+            cpu: parsed.cpu ?? "",
+            system_language: parsed.system_language ?? "",
+        };
+    }
+}
+export { DeviceHelper };

package/dist/helper/geoHelper.d.ts

@@ -0,0 +1,26 @@
+import type { GeoCoordinates } from "../types";
+declare class GeoHelper {
+    private static readonly CACHE_KEY_PREFIX;
+    private static readonly DEFAULT_TTL_MS;
+    private static cache;
+    private static pending;
+    private readonly baseUrl;
+    private readonly axiosInstance;
+    constructor(baseUrl: string);
+    static clearCache(): void;
+    private static storageKey;
+    private static readCache;
+    private static writeCache;
+    private fetchIPAddressAndLocation;
+    private fetchSharedLocation;
+    private loadGeoData;
+    private static toGeoCoordinates;
+    private static fallbackGeoCoordinates;
+    getGeoCoordinates(ttlMs?: number, forceRefresh?: boolean): Promise<GeoCoordinates>;
+    getIPAddress(ttlMs?: number, forceRefresh?: boolean): Promise<string>;
+    getGeoCoordinatesAndIPAddress(ttlMs?: number, forceRefresh?: boolean): Promise<{
+        geo_coordinates: GeoCoordinates;
+        ip_address: string;
+    }>;
+}
+export { GeoHelper };

package/dist/helper/geoHelper.js

@@ -0,0 +1,160 @@
+import axios from "axios";
+import { Endpoints } from "../constant/constant";
+class GeoHelper {
+    // #region Constants & State
+    static CACHE_KEY_PREFIX = "geo_coordinates_cache";
+    static DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+    static cache = new Map();
+    static pending = new Map();
+    baseUrl;
+    axiosInstance;
+    // #endregion
+    // #region Constructor
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl;
+        this.axiosInstance = axios.create({ baseURL: baseUrl });
+    }
+    // #endregion
+    // #region Cache
+    static clearCache() {
+        GeoHelper.cache.clear();
+        GeoHelper.pending.clear();
+        try {
+            const keysToRemove = [];
+            for (let i = 0; i < localStorage.length; i++) {
+                const key = localStorage.key(i);
+                if (key?.startsWith(GeoHelper.CACHE_KEY_PREFIX)) {
+                    keysToRemove.push(key);
+                }
+            }
+            keysToRemove.forEach((key) => localStorage.removeItem(key));
+        }
+        catch {
+            // Ignore errors when clearing cache
+        }
+    }
+    static storageKey(baseUrl) {
+        return `${GeoHelper.CACHE_KEY_PREFIX}:${baseUrl}`;
+    }
+    static readCache(baseUrl, ttlMs) {
+        const memEntry = GeoHelper.cache.get(baseUrl);
+        if (memEntry) {
+            if (Date.now() - memEntry.timestamp < ttlMs)
+                return memEntry;
+            GeoHelper.cache.delete(baseUrl);
+        }
+        try {
+            const cachedDataStr = localStorage.getItem(GeoHelper.storageKey(baseUrl));
+            if (!cachedDataStr)
+                return null;
+            const cachedData = JSON.parse(cachedDataStr);
+            if (Date.now() - cachedData.timestamp < ttlMs) {
+                GeoHelper.cache.set(baseUrl, cachedData);
+                return cachedData;
+            }
+            localStorage.removeItem(GeoHelper.storageKey(baseUrl));
+        }
+        catch (error) {
+            console.warn("Failed to read geo coordinates from cache:", error);
+        }
+        return null;
+    }
+    static writeCache(baseUrl, data) {
+        GeoHelper.cache.set(baseUrl, data);
+        try {
+            localStorage.setItem(GeoHelper.storageKey(baseUrl), JSON.stringify(data));
+        }
+        catch (error) {
+            console.warn("Failed to store geo coordinates in cache:", error);
+        }
+    }
+    // #endregion
+    // #region Helpers
+    async fetchIPAddressAndLocation() {
+        const response = await this.axiosInstance.get(Endpoints.IPAddress);
+        const ipAddressAndLocation = response.data.value;
+        if (!ipAddressAndLocation)
+            return null;
+        try {
+            return JSON.parse(ipAddressAndLocation);
+        }
+        catch (error) {
+            console.warn("Failed to parse IP address and location:", error);
+            return null;
+        }
+    }
+    // Dedupes concurrent fetches per baseURL so N callers on cold cache
+    // result in 1 network call instead of N.
+    fetchSharedLocation() {
+        const existing = GeoHelper.pending.get(this.baseUrl);
+        if (existing)
+            return existing;
+        const inflight = this.fetchIPAddressAndLocation();
+        GeoHelper.pending.set(this.baseUrl, inflight);
+        const cleanup = () => {
+            if (GeoHelper.pending.get(this.baseUrl) === inflight) {
+                GeoHelper.pending.delete(this.baseUrl);
+            }
+        };
+        inflight.then(cleanup, cleanup);
+        return inflight;
+    }
+    async loadGeoData(ttlMs, forceRefresh) {
+        if (!forceRefresh && ttlMs > 0) {
+            const cached = GeoHelper.readCache(this.baseUrl, ttlMs);
+            if (cached)
+                return cached;
+        }
+        const location = await this.fetchSharedLocation();
+        // Failed fetch returns fallback but does NOT cache it — a transient
+        // network blip should not poison the cache for 24h.
+        if (!location) {
+            return {
+                geo_coordinates: GeoHelper.fallbackGeoCoordinates(),
+                ip_address: "",
+                timestamp: Date.now(),
+            };
+        }
+        const data = {
+            geo_coordinates: GeoHelper.toGeoCoordinates(location),
+            ip_address: location.ip_address || "",
+            timestamp: Date.now(),
+        };
+        if (ttlMs > 0)
+            GeoHelper.writeCache(this.baseUrl, data);
+        return data;
+    }
+    static toGeoCoordinates(location) {
+        const { latitude, longitude, city, country } = location;
+        return {
+            latitude: (latitude ?? 0).toString(),
+            longitude: (longitude ?? 0).toString(),
+            position_description: `${city || "N/A"}, ${country || "N/A"}`,
+        };
+    }
+    static fallbackGeoCoordinates() {
+        return {
+            latitude: "0",
+            longitude: "0",
+            position_description: "N/A, N/A",
+        };
+    }
+    // #endregion
+    // #region Public API
+    async getGeoCoordinates(ttlMs = GeoHelper.DEFAULT_TTL_MS, forceRefresh = false) {
+        const data = await this.loadGeoData(ttlMs, forceRefresh);
+        return data.geo_coordinates;
+    }
+    async getIPAddress(ttlMs = GeoHelper.DEFAULT_TTL_MS, forceRefresh = false) {
+        const data = await this.loadGeoData(ttlMs, forceRefresh);
+        return data.ip_address ?? "";
+    }
+    async getGeoCoordinatesAndIPAddress(ttlMs = GeoHelper.DEFAULT_TTL_MS, forceRefresh = false) {
+        const data = await this.loadGeoData(ttlMs, forceRefresh);
+        return {
+            geo_coordinates: data.geo_coordinates,
+            ip_address: data.ip_address ?? "",
+        };
+    }
+}
+export { GeoHelper };

package/dist/helper/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./api";
+export * from "./cipherHelper";
+export * from "./clientHelper";
+export * from "./storage";
+export * from "./dateTimeHelper";
+export * from "./deviceHelper";
+export * from "./geoHelper";
+export * from "./userHelper";

package/dist/helper/index.js

@@ -0,0 +1,8 @@
+export * from "./api";
+export * from "./cipherHelper";
+export * from "./clientHelper";
+export * from "./storage";
+export * from "./dateTimeHelper";
+export * from "./deviceHelper";
+export * from "./geoHelper";
+export * from "./userHelper";

package/dist/helper/storage/cookiesHelper.d.ts

@@ -0,0 +1,64 @@
+import type { ChangeEventParameters } from "../../types/helper/storageHelper/cookiesHelper";
+import type { CredentialsCookies } from "../../types/storage/cookies";
+import type { USR } from "../../types/helper/cipherHelper";
+import { TokenData } from "../..";
+declare class CookiesHelper {
+    private key;
+    private pendingIID;
+    private eventHandlers;
+    private domain;
+    private programId;
+    private Cookies;
+    private useCookieStore;
+    private cipherHelper;
+    private errorHandler;
+    private cachedIID;
+    private cachedUSR;
+    private cachedDEK;
+    private cachedAccessToken;
+    private cachedJWTToken;
+    constructor(programId: string, domain: string, errorHandler: (error: any) => void);
+    /**
+     * Check if CookieStore API is available
+     * CookieStore requires secure context (HTTPS or localhost)
+     */
+    private isCookieStoreAvailable;
+    private isSecureContext;
+    private buildCookieName;
+    private clearCacheForKey;
+    private setCookieFallback;
+    private getCookieFallback;
+    private deleteCookieFallback;
+    getIID(): Promise<string>;
+    private _fetchOrCreateIID;
+    private setIID;
+    validateIID(installationId: string): Promise<boolean>;
+    getDEK(): Promise<string>;
+    setDEK(deviceEncryptionKey: string, USR: USR): Promise<void>;
+    validateDEK(DEK: string): Promise<boolean>;
+    getUserId(): Promise<number>;
+    getDeviceId(): Promise<number>;
+    getUSR(): Promise<USR | null>;
+    setUSR(deviceId: string, userId: string): Promise<void>;
+    validateUSR(USR: string): Promise<boolean>;
+    getDeviceSecurityCode(): Promise<string>;
+    getAccessToken(): Promise<string>;
+    setAccessToken(accessToken: string, expires: number): Promise<void>;
+    validateAccessToken(accessToken: string): Promise<boolean>;
+    getJWTToken(): Promise<string>;
+    setJWTToken(jwtToken: string): Promise<void>;
+    validateJWTToken(jwtToken: string): Promise<boolean>;
+    get(key: string): Promise<string>;
+    set(key: string, value: string, expires?: number): Promise<void>;
+    remove(key: string): Promise<void>;
+    setCredentialCookiesByTokenData(tokenData: TokenData): Promise<void>;
+    clearCredentialCookies(): Promise<void>;
+    cookieEventHandler(e: CookieChangeEvent, params: ChangeEventParameters): Promise<void>;
+    onChangeHandler(changed: CookieInit[], params: ChangeEventParameters): Promise<void>;
+    onDeleteHandler(deleted: CookieInit[], params: ChangeEventParameters): Promise<void>;
+    addOnChangeEventListener(id: string, params: ChangeEventParameters): void;
+    removeOnChangeEventListener(id: string): void;
+    isAuthenticated(): Promise<boolean>;
+    getCredentialsCookies(): Promise<CredentialsCookies>;
+}
+export { CookiesHelper };