@chainpatrol/sdk 0.4.0 → 0.5.0

package/dist/index.d.mts

@@ -0,0 +1,213 @@
+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 {
+    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 {
+    static StorageKeys: {
+        ALLOWLIST: string;
+        BLOCKLIST: string;
+        IGNORELIST: string;
+    };
+    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;
+        redirectUrl?: string | ((url: string) => string);
+    });
+    constructor({ mode, apiKey, storage, redirectUrl, }: {
+        mode: "cloud";
+        apiKey: string;
+        storage?: Storage;
+        redirectUrl?: string | ((url: string) => string);
+    });
+    constructor({ mode, apiKey, proxyUrl, storage, redirectUrl, }: {
+        mode: "cloud";
+        apiKey: string;
+        proxyUrl?: string;
+        storage?: Storage;
+        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 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>;
+};
+
+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, type index_Storage as Storage, index_defineStorage as defineStorage };
+}
+
+export { type AssetStatus, type AssetType, ChainPatrolClient, ChainPatrolClientError, ChainPatrolClientErrorCodes, type ChainPatrolClientOptions, type DetectorAssetStatus, DomainParseError, type EventData, Events, Relay, index as Storage, ThreatDetector, type URLResult };

package/dist/index.d.ts

@@ -77,9 +77,9 @@ declare class ChainPatrolClient {
             id: number;
             createdAt: Date;
             organization: {
-                slug: string;
-                name: string;
                 id: number;
+                name: string;
+                slug: string;
             } | null;
         }>;
     };
@@ -207,13 +207,7 @@ 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 { index_Browser as Browser, index_Extension as Extension, index_Memory as Memory, type 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, index as Storage, ThreatDetector, type URLResult };