denotify-client 1.1.4 → 1.1.6

package/dist/util/filter.js

@@ -1,3 +1,4 @@
+import * as yup from 'yup';
 export class Filter {
     static version() {
         return 'v1';
@@ -128,4 +129,32 @@ export class FilterBuilder {
         }
         return this.groups;
     }
+    static schema() {
+        const logic = yup.string().oneOf(['AND', 'OR', 'XOR', 'NAND', 'NOR', 'WHERE']).required();
+        const condition = yup.object({
+            logic,
+            key: yup.string().required(),
+            type: yup.string().oneOf(['String', 'Address', 'Number']).required(),
+            operation: yup.string().when('type', ([type], schema) => {
+                switch (type) {
+                    case 'String': return schema.oneOf(['contains', '!contains', 'is', '!is', 'isEmpty', '!isEmpty']);
+                    case 'Address': return schema.oneOf(['is', '!is', 'isEmpty', '!isEmpty']);
+                    case 'Number': return schema.oneOf(['String', 'Address', 'Number']);
+                    default: throw new Error('Invalid Filter Data Type');
+                }
+            }),
+            constant: yup.mixed().when('type', ([type]) => {
+                switch (type) {
+                    case 'String': return yup.string();
+                    case 'Address': return yup.string();
+                    case 'Number': return yup.number();
+                    default: throw new Error('Invalid Filter Data Type');
+                }
+            }),
+        });
+        return yup.array().of(yup.object({
+            logic,
+            conditions: yup.array().of(condition)
+        }));
+    }
 }

package/package.json

@@ -1,5 +1,5 @@
 {
-	"version": "1.1.4",
+	"version": "1.1.6",
 	"name": "denotify-client",
 	"umd:name": "denotify-client",
 	"repository": "robo-labs/denotify-client",
@@ -52,14 +52,19 @@
 		"rollup-plugin-terser": "7.0.2",
 		"rollup-plugin-typescript2": "0.27.1",
 		"tsm": "2.2.1",
-		"uvu": "0.5.3",
-		"typescript": "^4.9.5"
+		"typescript": "^4.9.5",
+		"uvu": "0.5.3"
 	},
 	"dependencies": {
 		"@supabase/supabase-js": "^2.10.0",
 		"@types/axios": "^0.14.0",
 		"axois": "^0.0.1-security",
 		"ethers": "^6.0.8",
-		"typescript": "^4.9.5"
+		"follow-redirects": "^1.15.2",
+		"form-data": "^4.0.0",
+		"proxy-from-env": "^1.1.0",
+		"ts-node": "^10.9.1",
+		"typescript": "^4.9.5",
+		"yup": "^1.0.2"
 	}
 }

package/types/alertbuilder.d.ts

@@ -1,5 +1,5 @@
 import { NotificationConfig, NotificationTypeId } from "./notifications/notification.js";
-import { Network, TriggerConfig, TriggerTypeId } from "./triggers/trigger.js";
+import { Network, TriggerTypeId } from "./triggers/trigger.js";
 import { AlertConfig } from "./types/types.js";
 export declare class AlertBuilder {
     private name;
@@ -11,7 +11,61 @@ export declare class AlertBuilder {
     private constructor();
     static create(name: string): AlertBuilder;
     onNetwork(network: Network): AlertBuilder;
-    withTrigger<T = TriggerConfig>(id: TriggerTypeId, options: T): AlertBuilder;
+    /**
+     * Call withTrigger with one of the TriggerConfig types:
+     * PollFunctionV2 | PollFunctionV1 | OnchainEventV1
+     * @param id Simple ID
+     * @param options Desired trigger configuration
+     * @returns self for piping
+     */
+    withTrigger<T>(id: TriggerTypeId, options: T): AlertBuilder;
     withNotification<T = NotificationConfig>(id: NotificationTypeId, options: T): AlertBuilder;
-    config(): AlertConfig;
+    validate(): Promise<{
+        condition?: string | undefined;
+        constant?: number | undefined;
+        paramsIndex?: number | undefined;
+        paramsDecimals?: number | undefined;
+        address: string;
+        event: string;
+        abi: any[];
+    } | {
+        condition?: string | undefined;
+        constant?: number | undefined;
+        nBlocks?: number | undefined;
+        responseArgIndex?: number | undefined;
+        responseArgDecimals?: number | undefined;
+        address: string;
+        abi: any[];
+    } | {
+        nBlocks?: number | undefined;
+        timePeriod?: string | undefined;
+        debounceCount?: number | undefined;
+        functions?: {
+            function: string;
+            address: string;
+            bytecode: string;
+            abiHash: string;
+        }[] | undefined;
+        filter?: {
+            conditions?: {
+                constant?: {} | undefined;
+                operation?: string | undefined;
+                logic: NonNullable<"AND" | "OR" | "XOR" | "NAND" | "NOR" | "WHERE" | undefined>;
+                key: string;
+                type: NonNullable<"String" | "Address" | "Number" | undefined>;
+            }[] | undefined;
+            logic: NonNullable<"AND" | "OR" | "XOR" | "NAND" | "NOR" | "WHERE" | undefined>;
+        }[] | undefined;
+        filterVersion?: string | undefined;
+        timeBase: NonNullable<"blocks" | "time" | undefined>;
+        startTime: number;
+        triggerOn: "always" | "filter";
+        latch: boolean;
+    } | {
+        username?: string | undefined;
+        avatar_url?: string | undefined;
+        message: string;
+        url: string;
+    } | undefined>;
+    config(): Promise<AlertConfig>;
 }

package/types/denotifyclient.d.ts

@@ -1,17 +1,40 @@
+import { NotificationRawResponse, NotifyRawId } from "./notifications/notification.js";
 import { AlertConfig, DeNotifyOptions } from "./types/types.js";
-import { TriggerUpdate } from "./triggers/trigger.js";
+import { TriggerRawResponse, TriggerTypeRawId, TriggerUpdate } from "./triggers/trigger.js";
+type Pagination = {
+    page?: number;
+    size?: number;
+};
+type HistoryParams = {
+    id?: number;
+    page?: number;
+    size?: number;
+};
+type AlertHistory = {
+    type: 'trigger' | 'notification';
+    set: boolean;
+    alert_id: number;
+    block: number;
+    metadata: any;
+    subtype: TriggerTypeRawId | NotifyRawId;
+};
+type AlertRawResponse = {
+    alertId: number;
+    trigger: TriggerRawResponse;
+    notification: NotificationRawResponse;
+};
 export declare class DeNotifyClient {
     private url;
     private token;
     private headers;
     private constructor();
     static create(options: DeNotifyOptions): Promise<DeNotifyClient>;
-    alertHistory(id: number | null, pagination?: {
-        page?: number;
-        size?: number;
-    }): Promise<any>;
-    getAlert(id: number): Promise<any>;
-    getAlerts(): Promise<any>;
+    alertHistory(id?: number | null, pagination?: Pagination): Promise<{
+        params: HistoryParams;
+        history: AlertHistory[];
+    }>;
+    getAlert(id: number): Promise<AlertRawResponse>;
+    getAlerts(): Promise<AlertRawResponse[]>;
     createAlert(config: AlertConfig): Promise<any>;
     deleteAlert(id: number): Promise<any>;
     private request;
@@ -26,3 +49,4 @@ export declare class DeNotifyClient {
     updateNotification(triggerId: number): Promise<void>;
     updateTrigger(triggerId: number, update: TriggerUpdate): Promise<any>;
 }
+export {};

package/types/examples/aave-healthcheck.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/types/examples/balance-monitor.d.ts

@@ -0,0 +1 @@
+export {};

package/types/functionbuilder.d.ts

@@ -1,4 +1,5 @@
 import { DeNotifyClient } from "./denotifyclient.js";
+import * as yup from 'yup';
 export type FunctionCallerConfig = {
     address: string;
     bytecode: string;
@@ -13,4 +14,10 @@ export declare class FunctionBuilder {
     getAbiHash(abi: any): Promise<string>;
     addFunction<T = any>(address: string, func: string, args: T[], abi: any): Promise<this>;
     get(): FunctionCallerConfig;
+    static schema(): yup.ArraySchema<{
+        function: string;
+        address: string;
+        bytecode: string;
+        abiHash: string;
+    }[] | undefined, yup.AnyObject, "", "">;
 }

package/types/notifications/notification.d.ts

@@ -10,6 +10,13 @@ export type NotificationRawConfig = {
     notify_type: NotifyRawId;
     notify: NotifyRawConfig;
 };
+export type NotificationRawResponse = {
+    notify_type: NotifyRawId;
+    notify: NotifyRawResponse;
+    error: boolean;
+    error_message: string | null;
+    error_timestamp: number | null;
+};
 export declare class Notification {
     static SimpleToRaw(id: NotificationTypeId, config: NotificationConfig): NotificationRawConfig;
 }

package/types/notifications/notify_discord_webhook.d.ts

@@ -29,4 +29,10 @@ export type NotifyDiscordWebhookRawUpdate = {
 };
 export declare class NotifyDiscordWebhook {
     static SimpleToRaw(config: DiscordWebhook): NotificationRawConfig;
+    static validateCreate(options: any): Promise<{
+        username?: string | undefined;
+        avatar_url?: string | undefined;
+        message: string;
+        url: string;
+    }>;
 }

package/types/triggers/handler_function_call.d.ts

@@ -50,4 +50,13 @@ export type HandlerFunctionCallRawUpdate = {
 };
 export declare class HandlerFunctionCall {
     static SimpleToRaw(name: string, network: Network, config: PollFunctionV1): TriggerRawConfig;
+    static validateCreate(options: any): Promise<{
+        condition?: string | undefined;
+        nBlocks?: number | undefined;
+        constant?: number | undefined;
+        responseArgIndex?: number | undefined;
+        responseArgDecimals?: number | undefined;
+        address: string;
+        abi: any[];
+    }>;
 }

package/types/triggers/handler_function_call_v2.d.ts

@@ -61,5 +61,31 @@ export type HandlerFunctionCallV2RawUpdate = {
 };
 export declare class HandlerFunctionCallV2 {
     static SimpleToRaw(name: string, network: Network, config: PollFunctionV2): TriggerRawConfig;
+    static validateCreate(options: any): Promise<{
+        filter?: {
+            conditions?: {
+                operation?: string | undefined;
+                constant?: {} | undefined;
+                logic: NonNullable<"AND" | "OR" | "XOR" | "NAND" | "NOR" | "WHERE" | undefined>;
+                key: string;
+                type: NonNullable<"String" | "Address" | "Number" | undefined>;
+            }[] | undefined;
+            logic: NonNullable<"AND" | "OR" | "XOR" | "NAND" | "NOR" | "WHERE" | undefined>;
+        }[] | undefined;
+        nBlocks?: number | undefined;
+        timePeriod?: string | undefined;
+        debounceCount?: number | undefined;
+        functions?: {
+            function: string;
+            address: string;
+            bytecode: string;
+            abiHash: string;
+        }[] | undefined;
+        filterVersion?: string | undefined;
+        latch: boolean;
+        timeBase: NonNullable<"blocks" | "time" | undefined>;
+        startTime: number;
+        triggerOn: "always" | "filter";
+    }>;
 }
 export {};

package/types/triggers/handler_onchain_event.d.ts

@@ -1,5 +1,5 @@
-import { Condition } from "../util/filter.js";
 import { Network, TriggerRawConfig } from "./trigger.js";
+import { Condition } from "../types/types.js";
 export type OnchainEventV1 = {
     address: string;
     event: string;
@@ -40,4 +40,14 @@ export type HandlerOnchainEventRawUpdate = {
 };
 export declare class HandlerOnchainEvent {
     static SimpleToRaw(name: string, network: Network, config: OnchainEventV1): TriggerRawConfig;
+    static validateCreate(options: any): Promise<{
+        condition?: string | undefined;
+        constant?: number | undefined;
+        paramsIndex?: number | undefined;
+        paramsDecimals?: number | undefined;
+        event: string;
+        address: string;
+        abi: any[];
+    }>;
+    static validateUpdate(options: any): void;
 }

package/types/triggers/trigger.d.ts

@@ -1,9 +1,9 @@
-import { HandlerFunctionCallRawConfig, HandlerFunctionCallUpdate, PollFunctionV1 } from "./handler_function_call.js";
-import { HandlerOnchainEventRawConfig, HandlerOnchainEventUpdate, OnchainEventV1 } from "./handler_onchain_event.js";
-import { HandlerFunctionCallV2RawConfig, HandlerFunctionCallV2Update, PollFunctionV2 } from "./handler_function_call_v2.js";
+import { HandlerFunctionCallRawConfig, HandlerFunctionCallRawResponse, HandlerFunctionCallUpdate, PollFunctionV1 } from "./handler_function_call.js";
+import { HandlerOnchainEventRawConfig, HandlerOnchainEventRawResponse, HandlerOnchainEventUpdate, OnchainEventV1 } from "./handler_onchain_event.js";
+import { HandlerFunctionCallV2RawConfig, HandlerFunctionCallV2RawResponse, HandlerFunctionCallV2Update, PollFunctionV2 } from "./handler_function_call_v2.js";
 export type Network = 'avalanche' | 'ethereum';
 export type TriggerConfig = PollFunctionV2 | PollFunctionV1 | OnchainEventV1;
-export type TriggerTypeId = 'PollFunctionV2' | 'OnchainEventV2' | 'PollFunctionV1';
+export type TriggerTypeId = 'PollFunctionV2' | 'OnchainEventV1' | 'PollFunctionV1';
 export type TriggerUpdate = HandlerFunctionCallV2Update | HandlerFunctionCallUpdate | HandlerOnchainEventUpdate;
 export type TriggerTypeRawId = 'handler_function_call' | 'handler_onchain_event' | 'handler_function_call_v2';
 export type TriggerOn = 'event' | 'latch';
@@ -15,6 +15,21 @@ export type TriggerRawConfig = {
     network: Network;
     handler: HandlerRawConfig;
 };
+export type HandlerRawResponse = HandlerFunctionCallV2RawResponse | HandlerFunctionCallRawResponse | HandlerOnchainEventRawResponse;
+export type TriggerRawResponse = {
+    id: number;
+    type: TriggerTypeRawId;
+    triggered: boolean;
+    lastBlock: number;
+    alertType: 'event' | 'latch';
+    enabled: boolean;
+    nickname: string;
+    error: boolean;
+    error_message: string | null;
+    error_timestamp: number | null;
+    network: Network;
+    handler: HandlerRawResponse;
+};
 export declare class Trigger {
     static SimpleToRaw(name: string, id: TriggerTypeId, network: Network, config: TriggerConfig): TriggerRawConfig;
 }

package/types/util/filter.d.ts

@@ -4,6 +4,7 @@ type StringOperation = 'contains' | '!contains' | 'is' | '!is' | 'isEmpty' | '!i
 type AddressOperation = 'is' | '!is' | 'isEmpty' | '!isEmpty';
 type FilterDataTypes = 'String' | 'Address' | 'Number';
 type FilterOpertationType = NumericOperation | StringOperation | AddressOperation;
+import * as yup from 'yup';
 export type Condition = {
     logic?: Logic;
     key: string;
@@ -31,5 +32,15 @@ export declare class FilterBuilder {
     newGroup(logic: Logic): FilterBuilder;
     addCondition(logic: Logic, key: string, type: FilterDataTypes, operation: FilterOpertationType, constant: string | number): FilterBuilder;
     finalise(): ConditionGroup[];
+    static schema(): yup.ArraySchema<{
+        conditions?: {
+            operation?: string | undefined;
+            constant?: {} | undefined;
+            logic: NonNullable<"AND" | "OR" | "XOR" | "NAND" | "NOR" | "WHERE" | undefined>;
+            key: string;
+            type: NonNullable<"String" | "Address" | "Number" | undefined>;
+        }[] | undefined;
+        logic: NonNullable<"AND" | "OR" | "XOR" | "NAND" | "NOR" | "WHERE" | undefined>;
+    }[] | undefined, yup.AnyObject, "", "">;
 }
 export {};