denotify-client 1.1.4 → 1.1.6

package/dist/alertbuilder.js

@@ -1,3 +1,7 @@
+import { NotifyDiscordWebhook } from "./notifications/notify_discord_webhook.js";
+import { HandlerFunctionCall } from "./triggers/handler_function_call.js";
+import { HandlerFunctionCallV2 } from "./triggers/handler_function_call_v2.js";
+import { HandlerOnchainEvent } from "./triggers/handler_onchain_event.js";
 export class AlertBuilder {
     name;
     network;
@@ -15,6 +19,13 @@ export class AlertBuilder {
         this.network = network;
         return this;
     }
+    /**
+     * 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(id, options) {
         this.triggerId = id;
         this.trigger = options;
@@ -25,13 +36,25 @@ export class AlertBuilder {
         this.notification = options;
         return this;
     }
-    config() {
+    async validate() {
+        // Validate trigger
+        switch (this.triggerId) {
+            case 'OnchainEventV1': return HandlerOnchainEvent.validateCreate(this.trigger);
+            case 'PollFunctionV1': return HandlerFunctionCall.validateCreate(this.trigger);
+            case 'PollFunctionV2': return HandlerFunctionCallV2.validateCreate(this.trigger);
+        }
+        switch (this.notificationId) {
+            case 'Discord': return NotifyDiscordWebhook.validateCreate(this.notification);
+        }
+    }
+    async config() {
         if (this.trigger === undefined || this.triggerId === undefined)
             throw new Error('Trigger not configured');
         if (this.notification === undefined || this.notificationId === undefined)
             throw new Error('Notification not configured');
         if (this.network === undefined)
             throw new Error('Network not configured');
+        await this.validate();
         return {
             name: this.name,
             network: this.network,

package/dist/denotifyclient.js

@@ -47,10 +47,19 @@ export class DeNotifyClient {
             throw new Error('Authentication Required. DeNotify supports either username/password or API key authentication');
         }
     }
-    async alertHistory(id, pagination = {}) {
-        const alerts = await this.request('get', `alert-history${id ? '/' + id : ''}`, { params: pagination });
-        return alerts;
+    async alertHistory(id, pagination) {
+        const url = `alert-history`;
+        const params = pagination ? pagination : {};
+        if (id)
+            params.id = id;
+        if (Object.keys(params).length > 0) {
+            return await this.request('get', url, { params: pagination });
+        }
+        else {
+            return await this.request('get', url);
+        }
     }
+    // TODO - Beutify the reponse
     async getAlert(id) {
         const alerts = await this.request('get', `alerts/${id}`);
         return alerts[0];
@@ -77,6 +86,7 @@ export class DeNotifyClient {
                 url.searchParams.append(param, options.params[param]);
             }
         }
+        console.log(url.toString());
         const payload = {
             method,
             url: url.toString(),

package/dist/examples/balance-monitor.js

@@ -0,0 +1,57 @@
+import { DeNotifyClient } from "../denotifyclient.js";
+// Simple App to demonstrate usage. Created a balance monitoring alert, updates it and deletes it
+async function main() {
+    const api = await DeNotifyClient.create({
+        email: 's.battenally@gmail.com',
+        password: 'Password',
+    });
+    // const alerts = await api.getAlerts()
+    const size = 100;
+    let page = 1;
+    let len = size;
+    while (len === size) {
+        console.log(`fetching page: ${page}, size: ${size}, id: ${123}`);
+        const ret = await api.alertHistory(123, { page, size });
+        console.log('success!');
+        console.log('length:', ret.history.length);
+        len = ret.history.length;
+        page++;
+    }
+    // const network = 'avalanche'
+    // const address = '0x26985888d5b7019ff2A7444fB567D8F386c3b538'
+    // const myAddress = '0x7601630eC802952ba1ED2B6e4db16F699A0a5A87'
+    // const { abi } = await api.getAbi(network, address)
+    // const webhook = process.env.DISCORD_WEBHOOK as string
+    // const builder = FunctionBuilder.create(api)
+    // await builder.addFunction(address, 'getBalance', [myAddress], abi)
+    // // Create the Balance Monitor alert
+    // const alert = await AlertBuilder.create('Test Alert')
+    // 	.onNetwork('avalanche')
+    // 	.withTrigger<PollFunctionV2>('PollFunctionV2', {
+    // 		timeBase: 'time',
+    // 		timePeriod: '100s',
+    // 		functions: builder.get(),
+    // 		triggerOn: 'always',
+    // 	})
+    // 	.withNotification<DiscordWebhook>('Discord', {
+    // 		url: webhook,
+    // 		message: 
+    // 		`Your avax balance is [{func_0_ret_0 / 1e18}](https://snowtrace.io/address/${myAddress})`,
+    // 	})
+    // 	.config()
+    // // Create the alert with the API
+    // const triggerId = await api.createAlert(alert)
+    // console.log(triggerId)
+    // // Update the period to every 10s
+    // await api.updateTrigger(triggerId, { timePeriod: '10s' })
+    // // Update the Filter using the filter builder
+    // const filter = FilterBuilder.new()
+    // 	.addCondition('WHERE', 'func_0_ret_0', 'Number', 'gt', 3)
+    // 	.finalise()
+    // await api.updateTrigger(13, { triggerOn: 'filter', filter, filterVersion: FilterBuilder.version() })
+    // // Delete the filter in 10s
+    // setTimeout(async () => {
+    // 	await api.deleteAlert(triggerId)
+    // }, 10 * 1000)
+}
+main();

package/dist/functionbuilder.js

@@ -1,4 +1,5 @@
 import { ethers } from "ethers";
+import * as yup from 'yup';
 export class FunctionBuilder {
     api;
     data = [];
@@ -27,4 +28,12 @@ export class FunctionBuilder {
     get() {
         return this.data;
     }
+    static schema() {
+        return yup.array().of(yup.object({
+            address: yup.string().required(),
+            bytecode: yup.string().matches(/^(0x)?([0-9a-fA-F]{2})*$/).required(),
+            abiHash: yup.string().matches(/^[A-Fa-f0-9]{64}/).required(),
+            function: yup.string().required()
+        }));
+    }
 }