@chainpatrol/sdk 0.4.1 → 0.6.0

package/README.md

@@ -2,4 +2,4 @@
 
 Typescript SDK for ChainPatrol.
 
-[Documentation](https://chainpatrol.io/docs/sdk/overview)
+[Documentation](https://chainpatrol.com/docs/sdk/overview)

package/dist/index.d.mts

@@ -0,0 +1,194 @@
+import { AssetCheckInput, AssetCheckOutput, AssetListInput, AssetListOutput, ReportCreateInput } from '@chainpatrol/validation';
+
+declare const ContinueAtOwnRisk = "CHAINPATROL_CONTINUE_AT_OWN_RISK";
+declare const IgnorelistUpdated = "CHAINPATROL_IGNORELIST_UPDATED";
+declare const CloseCurrentTab = "CHAINPATROL_CLOSE_CURRENT_TAB";
+declare const Events: {
+    readonly ContinueAtOwnRisk: "CHAINPATROL_CONTINUE_AT_OWN_RISK";
+    readonly IgnorelistUpdated: "CHAINPATROL_IGNORELIST_UPDATED";
+    readonly CloseCurrentTab: "CHAINPATROL_CLOSE_CURRENT_TAB";
+};
+type EventData = {
+    [ContinueAtOwnRisk]: {
+        domain: string;
+    };
+    [IgnorelistUpdated]: {
+        domain: string;
+    };
+    [CloseCurrentTab]: {};
+};
+
+type Handle = {
+    addListener: (callback: (message: any) => void) => void;
+    removeListener: (callback: (message: any) => void) => void;
+    postMessage: (message: any) => void;
+};
+/**
+ * Relay contains methods for implementing an event relay. It is used to
+ * forward events between Javascript contexts:
+ *
+ *   `<window>` <-> `<content script>` <-> `<background script>`
+ *
+ * Call `Relay.send` to send an event from one context to another. Call
+ * `Relay.on` to listen for events in the current context. Call `Relay.run`
+ * to start listening for events in the current context and forward them
+ * to all other contexts.
+ */
+declare class Relay {
+    protected static handles: Handle[];
+    private static readonly logger;
+    static send<EventType extends keyof EventData>(type: EventType, data: EventData[EventType]): void;
+    static run(events: (keyof EventData)[]): () => void;
+    private static handleMessage;
+    static on<EventType extends keyof EventData>(targetEvent: EventType, callback: (data: EventData[EventType]) => void): () => void;
+}
+
+type ChainPatrolClientOptions = {
+    apiKey: string;
+    baseUrl?: string;
+};
+type ApiRequest = {
+    path: string[];
+    method: "GET" | "POST" | "PUT" | "DELETE";
+    body?: unknown;
+};
+type AssetType = "URL" | "PAGE" | "ADDRESS";
+type AssetStatus = "ALLOWED" | "BLOCKED" | "UNKNOWN";
+declare class ChainPatrolClientError extends Error {
+    readonly code: ChainPatrolClientErrorCodes;
+    constructor(message: string, code: ChainPatrolClientErrorCodes);
+}
+declare enum ChainPatrolClientErrorCodes {
+    MISSING_API_KEY = "MISSING_API_KEY",
+    API_ERROR = "API_ERROR"
+}
+declare class ChainPatrolClient {
+    readonly baseUrl: string;
+    private readonly apiKey;
+    private readonly logger;
+    constructor(options: ChainPatrolClientOptions);
+    fetch<TResult = unknown>(req: ApiRequest): Promise<TResult>;
+    get asset(): {
+        check: (req: AssetCheckInput) => Promise<AssetCheckOutput>;
+        list: (req: AssetListInput) => Promise<AssetListOutput>;
+    };
+    get report(): {
+        create: (req: ReportCreateInput) => Promise<{
+            id: number;
+            createdAt: Date;
+            organization: {
+                id: number;
+                name: string;
+                slug: string;
+            } | null;
+        }>;
+    };
+}
+
+interface Storage$1 {
+    get: (key: string) => Promise<string | null>;
+    set: (key: string, value: string) => Promise<void>;
+    delete: (key: string) => Promise<void>;
+    size: () => Promise<number>;
+}
+
+type Prettify<T> = T extends infer U ? (U extends string ? U : never) : never;
+type DetectorAssetStatus = Prettify<AssetStatus | "IGNORED">;
+type URLResult = {
+    ok: true;
+    status: DetectorAssetStatus;
+    url: string;
+    redirectUrl?: string;
+} | {
+    ok: false;
+    url: string;
+    error: string;
+};
+declare class DomainParseError extends Error {
+    constructor(message: string);
+}
+declare class ThreatDetector {
+    private static readonly CHAINPATROL_WARNING_URL;
+    private static readonly Schema;
+    private mode;
+    private client?;
+    private storage;
+    private redirectUrl?;
+    private readonly logger;
+    constructor({ mode, storage, redirectUrl, }: {
+        mode: "local";
+        storage?: Storage$1;
+        redirectUrl?: string | ((url: string) => string);
+    });
+    constructor({ mode, apiKey, storage, redirectUrl, }: {
+        mode: "cloud";
+        apiKey: string;
+        storage?: Storage$1;
+        redirectUrl?: string | ((url: string) => string);
+    });
+    constructor({ mode, apiKey, proxyUrl, storage, redirectUrl, }: {
+        mode: "cloud";
+        apiKey: string;
+        proxyUrl?: string;
+        storage?: Storage$1;
+        redirectUrl?: string | ((url: string) => string);
+    });
+    url(url: string): Promise<URLResult>;
+    private generateDomains;
+    private urlHelper;
+    allow(url: string): Promise<{
+        ok: true;
+        url: string;
+    } | {
+        ok: false;
+        url: string;
+        error: string;
+    }>;
+    block(url: string): Promise<{
+        ok: true;
+        url: string;
+    } | {
+        ok: false;
+        url: string;
+        error: string;
+    }>;
+    ignore(url: string): Promise<{
+        ok: true;
+        url: string;
+    } | {
+        ok: false;
+        url: string;
+        error: string;
+    }>;
+    private parseDomainOrThrow;
+    private invalidateDomainInCaches;
+    private invalidateDomainInCache;
+    private addDomainToCache;
+    private isDomainInList;
+    private getListFromStorage;
+    private setListInStorage;
+    private getStatusFromCache;
+}
+
+declare const Storage: {
+    Memory: () => {
+        get: (key: string) => Promise<string | null>;
+        set: (key: string, value: string) => Promise<void>;
+        delete: (key: string) => Promise<void>;
+        size: () => Promise<number>;
+    };
+    Extension: () => {
+        get: (key: string) => Promise<any>;
+        set: (key: string, value: string) => Promise<void>;
+        delete: (key: string) => Promise<void>;
+        size: () => Promise<number>;
+    };
+    Browser: () => {
+        get: (key: string) => Promise<string | null>;
+        set: (key: string, value: string) => Promise<void>;
+        delete: (key: string) => Promise<void>;
+        size: () => Promise<number>;
+    };
+};
+
+export { type AssetStatus, type AssetType, ChainPatrolClient, ChainPatrolClientError, ChainPatrolClientErrorCodes, type ChainPatrolClientOptions, type DetectorAssetStatus, DomainParseError, type EventData, Events, Relay, Storage, ThreatDetector, type URLResult };

package/dist/index.d.ts

@@ -85,7 +85,7 @@ declare class ChainPatrolClient {
     };
 }
 
-interface Storage {
+interface Storage$1 {
     get: (key: string) => Promise<string | null>;
     set: (key: string, value: string) => Promise<void>;
     delete: (key: string) => Promise<void>;
@@ -108,11 +108,6 @@ declare class DomainParseError extends Error {
     constructor(message: string);
 }
 declare class ThreatDetector {
-    static StorageKeys: {
-        ALLOWLIST: string;
-        BLOCKLIST: string;
-        IGNORELIST: string;
-    };
     private static readonly CHAINPATROL_WARNING_URL;
     private static readonly Schema;
     private mode;
@@ -122,20 +117,20 @@ declare class ThreatDetector {
     private readonly logger;
     constructor({ mode, storage, redirectUrl, }: {
         mode: "local";
-        storage?: Storage;
+        storage?: Storage$1;
         redirectUrl?: string | ((url: string) => string);
     });
     constructor({ mode, apiKey, storage, redirectUrl, }: {
         mode: "cloud";
         apiKey: string;
-        storage?: Storage;
+        storage?: Storage$1;
         redirectUrl?: string | ((url: string) => string);
     });
     constructor({ mode, apiKey, proxyUrl, storage, redirectUrl, }: {
         mode: "cloud";
         apiKey: string;
         proxyUrl?: string;
-        storage?: Storage;
+        storage?: Storage$1;
         redirectUrl?: string | ((url: string) => string);
     });
     url(url: string): Promise<URLResult>;
@@ -175,45 +170,25 @@ declare class ThreatDetector {
     private getStatusFromCache;
 }
 
-declare const Extension: () => {
-    get: (key: string) => Promise<any>;
-    set: (key: string, value: string) => Promise<void>;
-    delete: (key: string) => Promise<void>;
-    size: () => Promise<number>;
-};
-
-declare const Browser: () => {
-    get: (key: string) => Promise<string | null>;
-    set: (key: string, value: string) => Promise<void>;
-    delete: (key: string) => Promise<void>;
-    size: () => Promise<number>;
-};
-
-declare const Memory: () => {
-    get: (key: string) => Promise<string | null>;
-    set: (key: string, value: string) => Promise<void>;
-    delete: (key: string) => Promise<void>;
-    size: () => Promise<number>;
+declare const Storage: {
+    Memory: () => {
+        get: (key: string) => Promise<string | null>;
+        set: (key: string, value: string) => Promise<void>;
+        delete: (key: string) => Promise<void>;
+        size: () => Promise<number>;
+    };
+    Extension: () => {
+        get: (key: string) => Promise<any>;
+        set: (key: string, value: string) => Promise<void>;
+        delete: (key: string) => Promise<void>;
+        size: () => Promise<number>;
+    };
+    Browser: () => {
+        get: (key: string) => Promise<string | null>;
+        set: (key: string, value: string) => Promise<void>;
+        delete: (key: string) => Promise<void>;
+        size: () => Promise<number>;
+    };
 };
 
-interface Context {
-    keys: string[];
-}
-declare function defineStorage<T extends Storage>(config: (ctx: Context) => T): () => T;
-
-declare const index_Browser: typeof Browser;
-declare const index_Extension: typeof Extension;
-declare const index_Memory: typeof Memory;
-type index_Storage = Storage;
-declare const index_defineStorage: typeof defineStorage;
-declare namespace index {
-  export {
-    index_Browser as Browser,
-    index_Extension as Extension,
-    index_Memory as Memory,
-    index_Storage as Storage,
-    index_defineStorage as defineStorage,
-  };
-}
-
-export { AssetStatus, AssetType, ChainPatrolClient, ChainPatrolClientError, ChainPatrolClientErrorCodes, ChainPatrolClientOptions, DetectorAssetStatus, DomainParseError, EventData, Events, Relay, index as Storage, ThreatDetector, URLResult };
+export { type AssetStatus, type AssetType, ChainPatrolClient, ChainPatrolClientError, ChainPatrolClientErrorCodes, type ChainPatrolClientOptions, type DetectorAssetStatus, DomainParseError, type EventData, Events, Relay, Storage, ThreatDetector, type URLResult };