@chainpatrol/sdk 0.1.1

package/README.md

@@ -0,0 +1,5 @@
+# `@chainpatrol/sdk`
+
+Typescript SDK for ChainPatrol.
+
+[Documentation](https://chainpatrol.io/docs/sdk/overview)

package/dist/index.d.ts

@@ -0,0 +1,225 @@
+declare const ContinueAtOwnRisk = "CHAINPATROL_CONTINUE_AT_OWN_RISK";
+declare const Events: {
+    readonly ContinueAtOwnRisk: "CHAINPATROL_CONTINUE_AT_OWN_RISK";
+};
+type EventData = {
+    [ContinueAtOwnRisk]: {
+        domain: string;
+    };
+};
+
+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 AssetType = "URL" | "PAGE" | "ADDRESS";
+type AssetStatus = "ALLOWED" | "BLOCKED" | "UNKNOWN";
+declare class ChainPatrolClient {
+    readonly baseUrl: string;
+    private readonly apiKey;
+    private readonly logger;
+    constructor(options: ChainPatrolClientOptions);
+    private fetch;
+    get asset(): {
+        check: (req: {
+            type: AssetType;
+            content: string;
+        }) => Promise<{
+            /**
+             * "ALLOWED" - the asset is on the allowlist
+             * "BLOCKED" - the asset is on the blocklist
+             * "UNKNOWN" - the asset's status is not known
+             */
+            status: AssetStatus;
+            /**
+             * If the asset is allowed or blocked, this will be the reason why.
+             * ChainPatrol aggregates data from multiple sources, so this will
+             * tell you which source blocked or allowed the asset.
+             *
+             * ex. 'eth-phishing-detect' - the asset is on MetaMask's blocklist
+             *     'reported' - the asset is on ChainPatrol's blocklist because
+             *                  it was reported by a user
+             */
+            reason?: string;
+        }>;
+        list: (req: {
+            /**
+             * Asset type
+             */
+            type: AssetType;
+            /**
+             * Status of the assets to retrieve
+             */
+            status: AssetStatus;
+            /**
+             * The start date to list assets from. This should be in the format `YYYY-MM-DD` and is inclusive.
+             */
+            startDate?: string;
+            /**
+             * The end date to list assets from. This should be in the format `YYYY-MM-DD` and is inclusive.
+             */
+            endDate?: string;
+        }) => Promise<{
+            content: string;
+            type: AssetType;
+            status: AssetStatus;
+        }[]>;
+    };
+}
+
+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 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,
+    index_Storage as Storage,
+    index_defineStorage as defineStorage,
+  };
+}
+
+export { AssetStatus, AssetType, ChainPatrolClient, ChainPatrolClientOptions, DetectorAssetStatus, DomainParseError, EventData, Events, Relay, index as Storage, ThreatDetector, URLResult };