radar-sdk-js 4.2.1-beta.0 → 4.2.1-beta.2

package/dist/radar.js.map

@@ -1 +1 @@
-{"version":3,"file":"radar.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"radar.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types.d.ts

@@ -52,6 +52,7 @@ export interface RadarTrackParams {
     metadata?: RadarMetadata;
     tripOptions?: RadarTripOptions;
     desiredAccuracy?: 'high' | 'medium' | 'low';
+    fraud?: boolean;
 }
 export declare enum RadarEventConfidence {
     none = 0,
@@ -59,7 +60,7 @@ export declare enum RadarEventConfidence {
     medium = 2,
     high = 3
 }
-export type RadarEventType = 'unknown' | 'user.entered_geofence' | 'user.entered_home' | 'user.entered_office' | 'user.entered_place' | 'user.entered_region_country' | 'user.entered_region_dma' | 'user.entered_region_state' | 'user.exited_geofence' | 'user.exited_home' | 'user.exited_office' | 'user.exited_place' | 'user.exited_region_country' | 'user.exited_region_dma' | 'user.exited_region_state' | 'user.nearby_place_chain' | 'user.started_traveling' | 'user.stopped_traveling' | 'user.started_commuting' | 'user.stopped_commuting' | 'user.started_trip' | 'user.updated_trip' | 'user.approaching_trip_destination' | 'user.arrived_at_trip_destination' | 'user.stopped_trip';
+export type RadarEventType = 'unknown' | 'user.entered_geofence' | 'user.entered_home' | 'user.entered_office' | 'user.entered_place' | 'user.entered_region_country' | 'user.entered_region_dma' | 'user.entered_region_state' | 'user.exited_geofence' | 'user.exited_home' | 'user.exited_office' | 'user.exited_place' | 'user.exited_region_country' | 'user.exited_region_dma' | 'user.exited_region_state' | 'user.nearby_place_chain' | 'user.started_traveling' | 'user.stopped_traveling' | 'user.started_commuting' | 'user.stopped_commuting' | 'user.started_trip' | 'user.updated_trip' | 'user.approaching_trip_destination' | 'user.arrived_at_trip_destination' | 'user.stopped_trip' | 'user.failed_fraud';
 export interface RadarGeofence {
     _id: string;
     description: string;
@@ -142,8 +143,11 @@ export interface RadarTrackResponse extends RadarResponse {
     user?: RadarUser;
     events?: RadarEvent[];
 }
-export interface RadarTrackTokenResponse extends RadarResponse {
+export interface RadarTrackVerifiedResponse extends RadarTrackResponse {
     token?: String;
+    expiresAt?: Date;
+    expiresIn?: number;
+    passed?: boolean;
 }
 export interface RadarContextResponse extends RadarResponse {
     location?: Location;
@@ -179,7 +183,7 @@ export interface RadarCustomEvent {
 export interface RadarConversionResponse extends RadarResponse {
     event: RadarCustomEvent;
 }
-export type RadarGeocodeLayer = 'place' | 'address' | 'intersection' | 'street' | 'neighborhood' | 'postalCode' | 'locality' | 'county' | 'state' | 'country' | 'coarse' | 'fine';
+export type RadarGeocodeLayer = 'place' | 'address' | 'postalCode' | 'locality' | 'county' | 'state' | 'country' | 'coarse' | 'fine';
 export interface RadarAddress {
     addressLabel?: string;
     borough?: string;
@@ -243,7 +247,9 @@ export interface RadarAutocompleteParams {
     limit?: number;
     layers?: RadarGeocodeLayer[];
     countryCode?: string;
+    /** @deprecated this is always true, regardless of the value passed here */
     expandUnits?: boolean;
+    mailable?: boolean;
 }
 export interface RadarAutocompleteResponse extends RadarResponse {
     addresses: RadarAutocompleteAddress[];
@@ -333,6 +339,7 @@ export interface RadarSearchGeofencesParams {
     tags?: string[] | string;
     metadata?: RadarMetadata;
     limit?: number;
+    includeGeometry?: boolean;
 }
 export interface RadarSearchGeofencesResponse extends RadarResponse {
     geofences: RadarGeofence[];
@@ -357,6 +364,7 @@ export interface RadarAutocompleteUIOptions {
     layers?: RadarGeocodeLayer[];
     countryCode?: string;
     expandUnits?: boolean;
+    mailable?: boolean;
     placeholder?: string;
     onSelection?: (selection: any) => void;
     onRequest?: (params: RadarAutocompleteParams) => void;

package/dist/util/jwt.d.ts

@@ -0,0 +1 @@
+export declare const signJWT: (payload: object, key: string) => Promise<string>;

package/dist/util/net.d.ts

@@ -0,0 +1 @@
+export declare const ping: (host: string) => Promise<any>;

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "4.2.1-beta.0";
+declare const _default: "4.2.1-beta.2";
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "radar-sdk-js",
-  "version": "4.2.1-beta.0",
+  "version": "4.2.1-beta.2",
   "description": "Web Javascript SDK for Radar, location infrastructure for mobile and web apps.",
   "homepage": "https://radar.com",
   "type": "module",

package/src/api/search.ts

@@ -22,6 +22,7 @@ class SearchAPI {
       layers,
       countryCode,
       expandUnits,
+      mailable,
     } = params;
 
     // near can be provided as a string or Location object
@@ -42,6 +43,7 @@ class SearchAPI {
         layers,
         countryCode,
         expandUnits,
+        mailable,
       },
     });
 
@@ -65,6 +67,7 @@ class SearchAPI {
       tags,
       metadata,
       limit,
+      includeGeometry,
     } = params;
 
     // use browser location if "near" not provided
@@ -90,6 +93,7 @@ class SearchAPI {
         tags,
         metadata,
         limit,
+        includeGeometry,
       },
     });
 

package/src/api/track.ts

@@ -6,16 +6,17 @@ import Logger from '../logger';
 import Navigator from '../navigator';
 import Session from '../session';
 import Storage from '../storage';
-
 import TripsAPI from './trips';
+import { signJWT } from '../util/jwt';
+import { ping } from '../util/net';
 
-import type { RadarTrackParams, RadarTrackResponse } from '../types';
+import type { RadarTrackParams, RadarTrackResponse, RadarTrackVerifiedResponse } from '../types';
 
 class TrackAPI {
   static async trackOnce(params: RadarTrackParams) {
     const options = Config.get();
 
-    let { latitude, longitude, accuracy, desiredAccuracy } = params;
+    let { latitude, longitude, accuracy, desiredAccuracy, fraud } = params;
 
     // if latitude & longitude are not provided,
     // try and retrieve device location (will prompt for location permissions)
@@ -42,6 +43,13 @@ class TrackAPI {
     const deviceType = params.deviceType || 'Web';
     const description = params.description || Storage.getItem(Storage.DESCRIPTION);
 
+    let timeZone;
+    try {
+      timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    } catch (err: any) {
+      Logger.warn(`Error getting time zone: ${err.message}`);
+    }
+
     // save userId for trip tracking
     if (!userId) {
       Logger.warn('userId not provided for trackOnce.');
@@ -75,9 +83,113 @@ class TrackAPI {
       stopped: true,
       userId,
       tripOptions,
+      timeZone,
     };
 
-    const response: any = await Http.request({
+    let response: any;
+    if (fraud) {
+      const host = 'https://api-verified.radar.io';
+      const pingHost = 'ping.radar-verify.com';
+
+      const lang = navigator.language;
+      const langs = navigator.languages;
+
+      const { dk }: any = await Http.request({
+        host,
+        method: 'GET',
+        path: 'config',
+        data: {
+          deviceId,
+          installId,
+          sessionId,
+          locationAuthorization,
+        },
+        headers: {
+          'X-Radar-Desktop-Device-Type': 'Web',
+        },
+      });
+
+      let sclVal = -1;
+      let cslVal = -1;
+      try {
+        const [sclRes, csl] = await Promise.all([
+          Http.request({
+            host: `https://${pingHost}`,
+            method: 'GET',
+            path: 'ping',
+          }),
+          ping(`wss://${pingHost}`),
+        ]);
+        const { scl }: any = sclRes;
+        sclVal = scl;
+        cslVal = csl;
+      } catch (err) {
+        // do nothing, send scl = -1 and csl = -1
+      }
+
+      const payload = {
+        payload: JSON.stringify({
+          ...body,
+          scl: sclVal,
+          csl: cslVal,
+          lang,
+          langs,
+        }),
+      };
+      
+      const reqToken = await signJWT(payload, dk);
+
+      response = await Http.request({
+        host,
+        method: 'POST',
+        path: 'track',
+        data: {
+          token: reqToken,
+        },
+        headers: {
+          'X-Radar-Body-Is-Token': 'true',
+        },
+      });
+
+      if (options.debug && response && response.user) {
+        if (!response.user.metadata) {
+          response.user.metadata = {};
+        }
+        
+        response.user.metadata['radar:debug'] = {
+          sclVal,
+          cslVal,
+        };
+      }
+
+      let { user, events, token, expiresAt } = response;
+      const location = { latitude, longitude, accuracy };
+      let passed;
+      let expiresIn;
+      if (expiresAt) {
+        expiresAt = new Date(expiresAt);
+        passed = user?.fraud?.passed && user?.country?.passed && user?.state?.passed;
+        expiresIn = (expiresAt.getTime() - Date.now()) / 1000;
+      }
+
+      const trackRes = {
+        user,
+        events,
+        location,
+        token,
+        expiresAt,
+        expiresIn,
+        passed,
+      } as RadarTrackVerifiedResponse;
+
+      if (options.debug) {
+        trackRes.response = response;
+      }
+
+      return trackRes;
+    }
+
+    response = await Http.request({
       method: 'POST',
       path: 'track',
       data: body,

package/src/api/verify.ts

@@ -6,7 +6,7 @@ import Logger from '../logger';
 import Session from '../session';
 import Storage from '../storage';
 
-import type { RadarTrackParams, RadarTrackResponse, RadarTrackTokenResponse } from '../types';
+import type { RadarTrackParams, RadarTrackVerifiedResponse } from '../types';
 
 class VerifyAPI {
   static async trackVerified(params: RadarTrackParams, encrypted: Boolean = false) {
@@ -44,16 +44,16 @@ class VerifyAPI {
     };
 
     let userAgent = navigator.userAgent;
-    const mac = userAgent && userAgent.toLowerCase().includes('mac');
+    const apple = userAgent && (userAgent.toLowerCase().includes('mac') || userAgent.toLowerCase().includes('iphone') || userAgent.toLowerCase().includes('ipod') || userAgent.toLowerCase().includes('ipad'));
 
     const response: any = await Http.request({
       method: 'GET',
       path: 'verify',
       data: body,
-      host: mac ? 'https://radar-verify.com:52516' : 'http://localhost:52516',
+      host: apple ? 'https://radar-verify.com:52516' : 'http://localhost:52516',
     });
 
-    const { user, events, token } = response;
+    let { user, events, token, expiresAt } = response;
     let location;
     if (user && user.location && user.location.coordinates && user.locationAccuracy) {
       location = {
@@ -62,24 +62,23 @@ class VerifyAPI {
         accuracy: user.locationAccuracy,
       };
     }
-
-    if (encrypted) {
-      const trackTokenRes = {
-        token,
-      } as RadarTrackTokenResponse;
-  
-      if (options.debug) {
-        trackTokenRes.response = response;
-      }
-  
-      return trackTokenRes;
+    let passed;
+    let expiresIn;
+    if (expiresAt) {
+      expiresAt = new Date(expiresAt);
+      passed = user?.fraud?.passed && user?.country?.passed && user?.state?.passed;
+      expiresIn = (expiresAt.getTime() - Date.now()) / 1000;
     }
 
     const trackRes = {
       user,
       events,
       location,
-    } as RadarTrackResponse;
+      token,
+      expiresAt,
+      expiresIn,
+      passed,
+    } as RadarTrackVerifiedResponse;
 
     if (options.debug) {
       trackRes.response = response;

package/src/errors.ts

@@ -23,19 +23,19 @@ export class RadarLocationError extends RadarError {
   }
 }
 
-export class RadarLocationPermissionsError extends RadarError {
+export class RadarPermissionsError extends RadarError {
   constructor(message: string) {
     super(message);
-    this.name = 'RadarLocationPermissionsError';
+    this.name = 'RadarPermissionsError';
     this.status = 'ERROR_PERMISSIONS';
   }
 }
 
-export class RadarDesktopAppError extends RadarError {
+export class RadarVerifyAppError extends RadarError {
   constructor() {
-    super('Desktop app not running.');
-    this.name = 'RadarDesktopAppError';
-    this.status = 'ERROR_DESKTOP_APP';
+    super('Radar Verify app not running.');
+    this.name = 'RadarVerifyAppError';
+    this.status = 'ERROR_VERIFY_APP';
   }
 }
 
@@ -131,11 +131,11 @@ export class RadarServerError extends RadarError {
   }
 }
 
-export class RadarTimeoutError extends RadarError {
+export class RadarNetworkError extends RadarError {
   constructor() {
     super('Request timed out.');
-    this.name = 'RadarTimeoutError';
-    this.status = 'ERROR_TIMED_OUT';
+    this.name = 'RadarNetworkError';
+    this.status = 'ERROR_NETWORK';
   }
 }
 

package/src/http.ts

@@ -4,18 +4,18 @@ import Logger from './logger';
 
 import {
   RadarBadRequestError,
-  RadarDesktopAppError,
   RadarForbiddenError,
   RadarLocationError,
-  RadarLocationPermissionsError,
+  RadarNetworkError,
   RadarNotFoundError,
   RadarPaymentRequiredError,
+  RadarPermissionsError,
   RadarPublishableKeyError,
   RadarRateLimitError,
   RadarServerError,
-  RadarTimeoutError,
   RadarUnauthorizedError,
   RadarUnknownError,
+  RadarVerifyAppError,
 } from './errors';
 
 export type HttpMethod = 'GET' | 'PUT' | 'PATCH' | 'POST' | 'DELETE';
@@ -31,11 +31,13 @@ class Http {
     path,
     data,
     host,
+    headers,
   }: {
     method: HttpMethod;
     path: string;
     data?: any;
     host?: string;
+    headers?: Record<string, string>;
   }) {
     return new Promise<HttpResponse>((resolve, reject) => {
       const options = Config.get();
@@ -76,13 +78,21 @@ class Http {
       const xhr = new XMLHttpRequest();
       xhr.open(method, url, true);
 
-      // set headers
+      // set standard headers
       xhr.setRequestHeader('Authorization', publishableKey);
       xhr.setRequestHeader('Content-Type', 'application/json');
       xhr.setRequestHeader('X-Radar-Device-Type', 'Web');
       xhr.setRequestHeader('X-Radar-SDK-Version', SDK_VERSION);
 
-      // set custom headers if present
+      // set passed custom headers if present
+      if (headers) {
+        Object.keys(headers).forEach(key => {
+          const val = headers[key];
+          xhr.setRequestHeader(key, val);
+        });
+      }
+
+      // set config custom headers if present
       if (typeof options.getRequestHeaders === 'function') {
         const headers: { [key: string]: string } = options.getRequestHeaders();
         Object.keys(headers || {}).forEach((key) => {
@@ -100,11 +110,11 @@ class Http {
 
         const error = response?.meta?.error;
         if (error === 'ERROR_PERMISSIONS') {
-          return reject(new RadarLocationPermissionsError('Location permissions not granted.'));
+          return reject(new RadarPermissionsError('Location permissions not granted.'));
         } else if (error === 'ERROR_LOCATION') {
           return reject(new RadarLocationError('Could not determine location.'));
         } else if (error === 'ERROR_NETWORK') {
-          return reject(new RadarTimeoutError());
+          return reject(new RadarNetworkError());
         }
 
         if (xhr.status == 200) {
@@ -143,15 +153,15 @@ class Http {
       }
 
       xhr.onerror = function() {
-        if (host && host === 'https://radar-verify.com:52516') {
-          reject(new RadarDesktopAppError());
+        if (host && (host === 'http://localhost:52516' || host === 'https://radar-verify.com:52516')) {
+          reject(new RadarVerifyAppError());
         } else {
           reject(new RadarServerError());
         }
       }
 
       xhr.ontimeout = function() {
-        reject(new RadarTimeoutError());
+        reject(new RadarVerifyAppError());
       }
 
       xhr.send(JSON.stringify(body));

package/src/index.ts

@@ -148,10 +148,6 @@ class Radar {
     return VerifyAPI.trackVerified(params);
   }
 
-  public static trackVerifiedToken(params: RadarTrackParams = {}) {
-    return VerifyAPI.trackVerified(params, true);
-  }
-
   public static getContext(params: Location) {
     return ContextAPI.getContext(params);
   }

package/src/navigator.ts

@@ -1,7 +1,7 @@
 import Config from './config';
 import Logger from './logger';
 import Storage from './storage';
-import { RadarLocationError, RadarLocationPermissionsError } from './errors';
+import { RadarLocationError, RadarPermissionsError } from './errors';
 
 import type { LocationAuthorization, NavigatorPosition } from './types';
 
@@ -9,13 +9,6 @@ interface PositionOptionOverrides {
   desiredAccuracy?: string;
 }
 
-// https://developer.mozilla.org/en-US/docs/Web/API/GeolocationPositionError
-const PERMISSION_ERROR_MESSAGES: any = {
-  1: 'Permission denied.',
-  2: 'Position unavailable.',
-  3: 'Timeout.',
-};
-
 const DEFAULT_POSITION_OPTIONS: PositionOptions = {
   maximumAge: 0,
   timeout: 1000 * 30, // 30 seconds
@@ -95,9 +88,11 @@ class Navigator {
           return resolve({ latitude, longitude, accuracy });
         },
         (err: GeolocationPositionError) => { // location call failed or user did not grant permission
-          if (err && err.code) {
-            const message = PERMISSION_ERROR_MESSAGES[err.code.toString()] || 'unknown';
-            return reject(new RadarLocationPermissionsError(message));
+          if (err && err.code === 1) {
+            // https://developer.mozilla.org/en-US/docs/Web/API/GeolocationPositionError
+            // code 1 means location permissions denied
+            // codes 2 and 3 mean location unavailable or timeout
+            return reject(new RadarPermissionsError('Location permissions denied.'));
           }
           return reject(new RadarLocationError('Could not determine location.'));
         },

package/src/types.ts

@@ -73,6 +73,7 @@ export interface RadarTrackParams {
   metadata?: RadarMetadata;
   tripOptions?: RadarTripOptions;
   desiredAccuracy?: 'high' | 'medium' | 'low';
+  fraud?: boolean;
 }
 
 export enum RadarEventConfidence {
@@ -107,7 +108,8 @@ export type RadarEventType =
   | 'user.updated_trip'
   | 'user.approaching_trip_destination'
   | 'user.arrived_at_trip_destination'
-  | 'user.stopped_trip';
+  | 'user.stopped_trip'
+  | 'user.failed_fraud';
 
 export interface RadarGeofence {
   _id: string;
@@ -211,8 +213,11 @@ export interface RadarTrackResponse extends RadarResponse {
   events?: RadarEvent[];
 }
 
-export interface RadarTrackTokenResponse extends RadarResponse {
+export interface RadarTrackVerifiedResponse extends RadarTrackResponse {
   token?: String;
+  expiresAt?: Date;
+  expiresIn?: number;
+  passed?: boolean;
 }
 
 export interface RadarContextResponse  extends RadarResponse {
@@ -257,9 +262,6 @@ export interface RadarConversionResponse extends RadarResponse {
 export type RadarGeocodeLayer =
   | 'place'
   | 'address'
-  | 'intersection'
-  | 'street'
-  | 'neighborhood'
   | 'postalCode'
   | 'locality'
   | 'county'
@@ -341,7 +343,9 @@ export interface RadarAutocompleteParams {
   limit?: number;
   layers?: RadarGeocodeLayer[];
   countryCode?: string;
+  /** @deprecated this is always true, regardless of the value passed here */
   expandUnits?: boolean;
+  mailable?: boolean;
 }
 
 export interface RadarAutocompleteResponse extends RadarResponse {
@@ -448,6 +452,7 @@ export interface RadarSearchGeofencesParams {
   tags?: string[] | string;
   metadata?: RadarMetadata;
   limit?: number;
+  includeGeometry?: boolean;
 }
 
 export interface RadarSearchGeofencesResponse extends RadarResponse {
@@ -476,6 +481,7 @@ export interface RadarAutocompleteUIOptions {
   layers?: RadarGeocodeLayer[];
   countryCode?: string;
   expandUnits?: boolean;
+  mailable?: boolean;
   placeholder?: string, // Placeholder text for the input field
   onSelection?: (selection: any) => void,
   onRequest?: (params: RadarAutocompleteParams) => void,

package/src/ui/autocomplete.ts

@@ -236,7 +236,7 @@ class AutocompleteUI {
   }
 
   public async fetchResults(query: string) {
-    const { limit, layers, countryCode, expandUnits, onRequest } = this.config;
+    const { limit, layers, countryCode, expandUnits, mailable, onRequest } = this.config;
 
     const params: RadarAutocompleteParams = {
       query,
@@ -244,6 +244,7 @@ class AutocompleteUI {
       layers,
       countryCode,
       expandUnits,
+      mailable,
     }
 
     if (this.near) {

package/src/util/jwt.ts

@@ -0,0 +1,28 @@
+const base64Encode = (str: string): string => 
+  btoa(str).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+
+export const signJWT = async (payload: object, key: string): Promise<string> => {
+  const encoder = new TextEncoder();
+
+  const encodedHeader = base64Encode(JSON.stringify({
+    alg: 'HS256',
+    typ: 'JWT',
+  }));
+  const encodedPayload = base64Encode(JSON.stringify(payload));
+
+  const keyData = encoder.encode(key);
+  const messageData = encoder.encode(`${encodedHeader}.${encodedPayload}`);
+
+  const cryptoKey = await crypto.subtle.importKey(
+    'raw',
+    keyData,
+    { name: 'HMAC', hash: { name: 'SHA-256' } },
+    false,
+    ['sign']
+  );
+
+  const signatureArrayBuffer = await crypto.subtle.sign('HMAC', cryptoKey, messageData);
+  const signature = base64Encode(String.fromCharCode(...Array.from(new Uint8Array(signatureArrayBuffer))));
+
+  return `${encodedHeader}.${encodedPayload}.${signature}`;
+};